예제 #1
0
    def atresplayer_mobile(self):
        #stream = self.__get(self.url)
        stream = Descargar.get(self.url)
        episode = re.findall('episode="(.*)">', stream)[0]
        header = {"Accept":"application/json"}
        j = json.loads(Descargar.getHtmlHeaders("http://servicios.atresplayer.com/episode/get?episodePk="+episode, header=header))

        if j['type'] == "REGISTER":
            url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
            #self.debug(unicode(url))
            #jj = json.loads(Descargar.getHtmlHeaders(Utiles.url_fix(url)))
            try:
                #url2down = jj['resultDes']
                url2down = url
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
        elif j['type'] == "FREE": # TEMP FIX
            url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
            try:
                url2down = url
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
        else:
            url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
            self.debug(unicode(url))
            #jj = json.loads(self.__get(Utiles.url_fix(url)))
            jj = json.loads(Descargar.get(Utiles.url_fix(url)))
            try:
                url2down = jj['resultObject']['es']
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))

            if url2down is None:
                raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")

            

        title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
        desc = unicode(j['seoDescription']).encode('utf-8')
        name = u"VideoAtresPlayer.mp4"
        img = j['urlImage'].replace(".jpg", "06.jpg")

        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [url2down] if type(url2down) != list else url2down,
                        "url_img"   : img if img is not None else None,
                        "filename"  : [name] if type(name) != list else name,
                        "tipo"      : "http",
                        "partes"    : 1 if type(url2down) != list else len(url2down),
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [title] if title is not None else None,
                "descs": [desc] if desc is not None else None
                }
예제 #2
0
    def __getUrl2down(self, ID, startTime, endTime, html):
        """
            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
        """
        self.debug(u"Probando el que era el Método 3")
        tokenizer = self.TOKENIZER
        server_time = Descargar.get(self.URL_TIME).strip()
        toEncode = server_time + ";" + ID + ";" + startTime + ";" + endTime
        data = Descargar.get("http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s" % (toEncode))
        post_args = {"hash": data, "id": ID.replace(" ", ""), "startTime": "0", "endTime": "0"}
        self.debug(u"Token: %s" % post_args)

        try:
            # data = Descargar.doPOST(self.URL_POST, tokenizer, post_args, doseq=True)
            data = Descargar.doPOST("aabilio.hl161.dinaserver.com", "/pydowntv/mitele2.php", post_args, doseq=True)
        except Exception, e:
            raise Error.GeneralPyspainTVsError("mitele.es: Error en Tokenizer: " + e.__str__())
예제 #3
0
 def __getUrl2down(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
     '''
     self.debug(u"Probando el que era el Método 3")
     AES = aes.AES() 
     #tokenizer = self.TOKENIZER
     server_time = Descargar.get(self.URL_TIME).strip()
     toEncode = server_time+";"+ID+";"+startTime+";"+endTime
     data = AES.encrypt(toEncode, p('eG84NWtUK1FIejNmUk1jSE1YcDljQQ=='), 256)
     post_args = {
                 'hash' : data,
                 'id' : ID,
                 'startTime' : '0',
                 'endTime': '0'
                 }
     
     try:
         #data = Descargar.doPOST(self.URL_POST, tokenizer, post_args, doseq=True)
         data = Descargar.doPOST("aabilio.me", "/pydowntv/mitele.php", post_args, doseq=True)
     except Exception, e:
         raise Error.GeneralPyspainTVsError("mitele.es: Error en Tokenizer: "+e.__str__())
예제 #4
0
    def __getUrl2down(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
        """
        self.debug(u"Probando el que era el Método 3")
        AES = aes.AES()
        tokenizer = self.TOKENIZER
        passwd = self.PASSWD
        server_time = Descargar.get(self.URL_TIME).strip()
        toEncode = server_time + ";" + ID + ";" + startTime + ";" + endTime
        data = AES.encrypt(toEncode, passwd, 256)
        post_args = {"hash": data, "id": ID, "startTime": "0", "endTime": "0"}

        try:
            data = Descargar.doPOST(self.URL_POST, tokenizer, post_args, doseq=True)
            # data = Descargar.doPOST("linfox.es", "/pydowntv/mitele.php", post_args, doseq=True)
        except Exception, e:
            raise Error.GeneralPyspainTVsError("mitele.es: Error en Tokenizer: " + e.__str__())
예제 #5
0
파일: historia.py 프로젝트: spds1/PyDownTV2
    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__())
예제 #6
0
    def __modoSalon(self, streamHTML):
        #TODO: Poner cada Canal su URL, no solo a todos la de antena 3 ;)
        self.log(u"[INFO] Modo Salón")
        if streamHTML.find("so.addVariable(\"xml\"") != -1:
            streamXML = \
            Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split("so.addVariable(\"xml\",\"")[1].split("\"")[0])
        elif streamHTML.find("player_capitulo.xml='") != -1:
            streamXML = \
            Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split("player_capitulo.xml='")[1].split("'")[0])
        else:
            if streamHTML.find("<div class=\"premium\">") != -1:
                raise Error.GeneralPyspainTVsError(
                    u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
                )
            raise Error.GeneralPyspainTVsError(
                u"Grupo Antena 3. No se encuentra XML.")

        self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
        # Comprobar aquí si se puede descargar 000.mp4:
        if streamXML.find(".mp4") != -1:
            tipo = ".mp4"
            #url2down1 = self.URL_DE_DESCARGA + \
            #    streamXML.split("<archivo><![CDATA[")[1].split("001.mp4]]></archivo>")[0] + "000.mp4"
        elif streamXML.find(".flv") != -1:
            tipo = ".flv"
            #url2down1 = self.URL_DE_DESCARGA + \
            #    streamXML.split("<archivo><![CDATA[")[1].split("001.flv]]></archivo>")[0] + "000.flv"
        elif streamXML.find(".f4v") != -1:
            [url2down, name] = self.__modoSalonNuevo(streamXML)
            return [url2down, name]
        else:
            raise Error.GeneralPyspainTVsError(
                "Grupo Antena 3. No se encuentra mp4, f4v ni flv")

        #if Descargar.isReachable(url2down1): # Vídeo completo en una parte
        #    url2down = url2down1
        #    name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + tipo
        #else: # Vídeo en varias partes
        #self.info(u"[!!!]  No se puede encuentra el vídeo en un archivo (000.mp4)")
        self.info(u"[INFO] El vídeo consta de varias partes")
        parts = re.findall(
            "\<archivo\>\<\!\[CDATA\[.*" + tipo + "\]\]\>\<\/archivo\>",
            streamXML)
        if parts:
            name1 = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0]
            url2down = []
            name = []
            for i in parts:
                url2down.append(
                    self.URL_DE_DESCARGA +
                    i.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0])
                name.append(name1 + "_" + i.split("]")[0].split("/")[-1])
        else:
            raise Error.GeneralPyspainTVsError(
                u"Grupo Antena 3. No se encuentra niguna parte de contenido.")
        return [url2down, name]
예제 #7
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)
     '''
     
     html = self.gethtml()
     
     if html.find("'file'") == -1:
         urlXML = self.URL_GET_XML+Utiles.recortar(html, "var idvideo = '", "'")
     else:
         urlXML = self.URL_HIST_CARTA+Utiles.unescape(Utiles.recortar(html, "'file': '", "'"))        
     
     import logging
     logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
     logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
     xml = Descargar.get(urlXML)
     if xml.find("vohWwiQliW") != -1: # GEOLOCALIZADO
         logging.debug("GEO")
         xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
         if xml.find("vohWwiQliW") != -1:
             logging.debug("GEO2")
             try:
                 xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
             except Exception, e:
                 raise Error.GeneralPyspainTVsError(e.__str__())
    def 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],
                }
예제 #9
0
파일: mitele.py 프로젝트: spds1/PyDownTV2
    def getInfo(self):
        '''
            Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
            {
             "exito"     : bool,  <-- True (si se han obtenido videos)
             "num_video" : int,   <-- Número de vídeos obtenidos
             "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
             "videos"    :  [{
                            "url_video" : [],   <-- Url de descarga de vídeo
                            "url_img"   : "",   <-- Url de la miniatura del video
                            "filename"  : [],   <-- Nombre de las partes para guardar en disco
                            "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                            "partes"    : int,  <-- Número de partes que tiene el vídeo
                            "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                            "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                            "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                            "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                            "mensaje"   : ""    <-- Mensajes de la API
                            }], <-- Debe ser una lista de tamaño "num_videos"
             "titulos"   : [u""], <-- Titulos de los videos
             "descs"     : [u""] <-- Descripción de cada vídeo
            }
            
            Los valores que no se rellenen, deberán devolver None.
            La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
            {
            "exito": False,
            "mensaje": "No se pudo descargar el video"  
            }
            
            "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
            "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
        '''

        tit_vid = None
        # Obtener HTML y XML:
        try:
            #streamHTML = htmlBackup = Descargar.getHtml(self.url).decode('string-escape')
            streamHTML = htmlBackup = Descargar.get(
                self.url, withHeader=True).decode('string-escape')
            html = streamHTML
            tit_vid = streamHTML.split("<title>")[1].split("<")[0]
            streamHTML = streamHTML.replace(" ", "")
            #streamXML = Descargar.getHtml(streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace("\/", "/"))
            streamXML = Descargar.get(
                streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace(
                    "\/", "/"),
                withHeader=True)
        except Exception, e:
            raise Error.GeneralPyspainTVsError(
                "mitele.es: No se puede obenter enlaces: " + e.__str__())
예제 #10
0
    def __modoSalon(self, streamHTML):
        # TODO: Poner cada Canal su URL, no solo a todos la de antena 3 ;)
        self.log(u"[INFO] Modo Salón")
        if streamHTML.find('so.addVariable("xml"') != -1:
            streamXML = Descargar.getHtml(
                self.URL_DE_ANTENA3 + streamHTML.split('so.addVariable("xml","')[1].split('"')[0]
            )
        elif streamHTML.find("player_capitulo.xml='") != -1:
            streamXML = Descargar.getHtml(
                self.URL_DE_ANTENA3 + streamHTML.split("player_capitulo.xml='")[1].split("'")[0]
            )
        else:
            if streamHTML.find('<div class="premium">') != -1:
                raise Error.GeneralPyspainTVsError(
                    u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
                )
            raise Error.GeneralPyspainTVsError(u"Grupo Antena 3. No se encuentra XML.")

        self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
        # Comprobar aquí si se puede descargar 000.mp4:
        if streamXML.find(".mp4") != -1:
            tipo = ".mp4"
            # url2down1 = self.URL_DE_DESCARGA + \
            #    streamXML.split("<archivo><![CDATA[")[1].split("001.mp4]]></archivo>")[0] + "000.mp4"
        elif streamXML.find(".flv") != -1:
            tipo = ".flv"
            # url2down1 = self.URL_DE_DESCARGA + \
            #    streamXML.split("<archivo><![CDATA[")[1].split("001.flv]]></archivo>")[0] + "000.flv"
        elif streamXML.find(".f4v") != -1:
            [url2down, name] = self.__modoSalonNuevo(streamXML)
            return [url2down, name]
        else:
            raise Error.GeneralPyspainTVsError("Grupo Antena 3. No se encuentra mp4, f4v ni flv")

        # if Descargar.isReachable(url2down1): # Vídeo completo en una parte
        #    url2down = url2down1
        #    name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + tipo
        # else: # Vídeo en varias partes
        # self.info(u"[!!!]  No se puede encuentra el vídeo en un archivo (000.mp4)")
        self.info(u"[INFO] El vídeo consta de varias partes")
        parts = re.findall("\<archivo\>\<\!\[CDATA\[.*" + tipo + "\]\]\>\<\/archivo\>", streamXML)
        if parts:
            name1 = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0]
            url2down = []
            name = []
            for i in parts:
                url2down.append(self.URL_DE_DESCARGA + i.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0])
                name.append(name1 + "_" + i.split("]")[0].split("/")[-1])
        else:
            raise Error.GeneralPyspainTVsError(u"Grupo Antena 3. No se encuentra niguna parte de contenido.")
        return [url2down, name]
예제 #11
0
    def __mediasetSearch(self, html):
        mediasetchannel = re.findall('s.eVar3="(.*)"', html)[0]
        programa = re.findall('s.eVar7="(.*)"', html)[0]
        temporada = re.findall('s.eVar8=".* ([0-9].*)"', html)[0]
        capitulo = re.findall('s.eVar9=".* ([0-9].*)"', html)[0]
        
        if int(temporada)<10: temporada="0%s" % (temporada)
        if int(capitulo)<10: capitulo="0%s" % (capitulo)

        abuscar = urllib2.quote("%s T%sxC%s" % (programa, temporada, capitulo))
        search = "http://www.%s.es/buscador/?text=%s" % (mediasetchannel, abuscar)
        self.debug(u"Programa: %s" % programa)
        self.debug(u"Temporada: %s" % temporada)
        self.debug(u"Capitulo: %s" % capitulo)
        self.debug(u"Search... %s" % search)
        results = Descargar.get(search)
        self.debug(search)
        try:
            r=results.split('<h2 class="headline')[1].split('href="')[1].split('"')[0]
        except IndexError:
            raise Error.GeneralPyspainTVsError("mitele.es: RTMP no soportado para el canal por ahora.")
        mediasetLink = "http://www.%s.es%s" % (mediasetchannel, r)

        if mediasetchannel == "telecinco":
            from telecinco import Telecinco as newChannel
        elif mediasetchannel == "cuatro":
            from cuatro import Cuatro as newChannel
        else:
            raise Error.GeneralPyspainTVsError("mitele.es: RTMP no soportado para el canal por ahora.")
        channel = newChannel(mediasetLink)
        return channel.getInfo()
예제 #12
0
    def __mediasetSearch(self, html):
        mediasetchannel = re.findall('s.eVar3="(.*)"', html)[0]
        programa = re.findall('s.eVar7="(.*)"', html)[0]
        temporada = re.findall('s.eVar8=".* ([0-9].*)"', html)[0]
        capitulo = re.findall('s.eVar9=".* ([0-9].*)"', html)[0]

        if int(temporada) < 10: temporada = "0%s" % (temporada)
        if int(capitulo) < 10: capitulo = "0%s" % (capitulo)

        abuscar = urllib2.quote("%s T%sxC%s" % (programa, temporada, capitulo))
        search = "http://www.%s.es/buscador/?text=%s" % (mediasetchannel,
                                                         abuscar)
        self.debug(u"Programa: %s" % programa)
        self.debug(u"Temporada: %s" % temporada)
        self.debug(u"Capitulo: %s" % capitulo)
        self.debug(u"Search... %s" % search)
        results = Descargar.get(search)
        self.debug(search)
        try:
            r = results.split('<h2 class="headline')[1].split(
                'href="')[1].split('"')[0]
        except IndexError:
            raise Error.GeneralPyspainTVsError(
                "mitele.es: RTMP no soportado para el canal por ahora.")
        mediasetLink = "http://www.%s.es%s" % (mediasetchannel, r)

        if mediasetchannel == "telecinco":
            from telecinco import Telecinco as newChannel
        elif mediasetchannel == "cuatro":
            from cuatro import Cuatro as newChannel
        else:
            raise Error.GeneralPyspainTVsError(
                "mitele.es: RTMP no soportado para el canal por ahora.")
        channel = newChannel(mediasetLink)
        return channel.getInfo()
예제 #13
0
 def __modoNormalConURL(self,  streamHTML):
     url2down = streamHTML.split(".seoURL='")[1].split("'")[0]
     if not Descargar.isReachable(url2down): # A veces el vídeo de .seoURL da NOT FOUND!
         xmlURL = Utiles.recortar(streamHTML, ".xml=\'", "\'")
         streamXML = Descargar.getHtml(self.URL_DE_ANTENA3 + xmlURL)
         self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
         url2down =  self.URL_DE_DESCARGA + \
         streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
         name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
         return [url2down, name]
     url2down = url2down.replace("deslasexta", "desprogresiva")
     try: # Parece que a veces aunque en el código aparezca el html, este no existe..
         name = Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split(".xml='")[1].split("'")[0]).split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
     except:
         name = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip() + ".mp4" 
     return [url2down,  name]
예제 #14
0
 def __modoNormalUnaParte(self, streamHTML):
     xmlURL = streamHTML.split("A3Player.swf?xml=")[1].split('"')[0]
     streamXML = Descargar.getHtml(xmlURL)
     self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
     url2down = self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
     name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
     return [url2down, name]
예제 #15
0
 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
             }
예제 #16
0
 def __modoSalonNuevo(self, streamXML):
     '''Nuevos vídeos con extensión .m4v'''
     self.log(u"[INFO] Modo Salón")
     self.log(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"
     
     if Descargar.isReachable(url2down1): # Vídeo en una parte
         url2down = url2down1
         name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".f4v"
     else: # Vídeo en varias partes
         self.info(u"[!!!]  No se puede encuentra el vídeo en un archivo (000.m4v)")
         self.info(u"[INFO] El vídeo consta de varias 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:
             raise Error.GeneralPyspainTVsError("Grupo Antena 3. No se encuentra ninguna parte de contenido.")
     return [url2down,  name]
예제 #17
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)
     '''
     
     tit_vid = None
     # Obtener HTML y XML:
     try:
         #streamHTML = htmlBackup = Descargar.getHtml(self.url).decode('string-escape')
         streamHTML = htmlBackup = Descargar.get(self.url, withHeader=True).decode('string-escape')
         html = streamHTML
         tit_vid = streamHTML.split("<title>")[1].split("<")[0]
         streamHTML = streamHTML.replace(" ", "")
         #streamXML = Descargar.getHtml(streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace("\/", "/"))
         streamXML = Descargar.get(streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace("\/", "/"), withHeader=True)
     except Exception, e:
         raise Error.GeneralPyspainTVsError("mitele.es: No se puede obenter enlaces: "+e.__str__())
예제 #18
0
 def __modoNormalUnaParte(self, streamHTML):
     xmlURL = streamHTML.split("A3Player.swf?xml=")[1].split("\"")[0]
     streamXML = Descargar.getHtml(xmlURL)
     self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
     url2down =  self.URL_DE_DESCARGA + \
     streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
     name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
     return [url2down, name]
예제 #19
0
    def atresplayer_mobile(self):
        #stream = self.__get(self.url)
        stream = Descargar.get(self.url)
        episode = re.findall('episode="(.*)">', stream)[0]
        header = {"Accept":"application/json"}
        j = json.loads(Descargar.getHtmlHeaders(self.URL_EPISODE_INFO+episode, header=header))

        url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
        self.debug(unicode(url))
        #jj = json.loads(self.__get(Utiles.url_fix(url)))
        jj = json.loads(Descargar.get(Utiles.url_fix(url)))
        try:
            url2down = jj['resultObject']['es']
        except:
            raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))

        if url2down is None:
            raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")

        title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
        desc = unicode(j['seoDescription']).encode('utf-8')
        urlparsed = urlparse.urlparse(self.url)
        pathsplit = urlparsed.path.split('/')
        del pathsplit[:3]
        name = u'_'.join(pathsplit)
        name = name.replace('.html','.mp4')
        img = j['urlImage'].replace(".jpg", "06.jpg")

        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [url2down] if type(url2down) != list else url2down,
                        "url_img"   : img if img is not None else None,
                        "filename"  : [name] if type(name) != list else name,
                        "tipo"      : "http",
                        "partes"    : 1 if type(url2down) != list else len(url2down),
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [title] if title is not None else None,
                "descs": [desc] if desc is not None else None
                }
예제 #20
0
파일: tv3.py 프로젝트: rkmax/PyDownTV2
    def __catradio(self):
        '''Procesa los audios de catradio'''
        # Primero nos quedamos con el ID
        audioID = self.url.split("/")[4]
        self.info(u"[INFO] Audio ID:", audioID)
        IDsplit = "insertNewItem(\'" + audioID + "\'"
        # Nos quedamos con su identificacion
        streamID = Descargar.get(self.url).split(IDsplit)[1].split(">")[0]
        name = streamID.split(",")[1] + ".mp3"
        url = "http://" + streamID.split("http://")[1].split("\'")[0]

        return [url, name]
예제 #21
0
 def __catradio(self):
     '''Procesa los audios de catradio'''
     # Primero nos quedamos con el ID
     audioID = self.url.split("/")[4]
     self.info(u"[INFO] Audio ID:", audioID)
     IDsplit = "insertNewItem(\'" + audioID + "\'"
     # Nos quedamos con su identificacion
     streamID = Descargar.get(self.url).split(IDsplit)[1].split(">")[0]
     name = streamID.split(",")[1] + ".mp3"
     url = "http://" + streamID.split("http://")[1].split("\'")[0]
     
     return [url, name]
예제 #22
0
 def __modoNormalConURL(self, streamHTML):
     url2down = streamHTML.split(".seoURL='")[1].split("'")[0]
     if not Descargar.isReachable(
             url2down):  # A veces el vídeo de .seoURL da NOT FOUND!
         xmlURL = Utiles.recortar(streamHTML, ".xml=\'", "\'")
         streamXML = Descargar.getHtml(self.URL_DE_ANTENA3 + xmlURL)
         self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
         url2down =  self.URL_DE_DESCARGA + \
         streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
         name = streamXML.split("<nombre><![CDATA[")[1].split(
             "]]>")[0] + ".mp4"
         return [url2down, name]
     url2down = url2down.replace("deslasexta", "desprogresiva")
     try:  # Parece que a veces aunque en el código aparezca el html, este no existe..
         name = Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split(
             ".xml='")[1].split("'")[0]).split(
                 "<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
     except:
         name = Utiles.recortar(streamHTML, "<title>", "</title>").replace(
             "ANTENA 3 TV", "").replace("-", "").strip() + ".mp4"
     return [url2down, name]
예제 #23
0
 def geturlfetch(self, url_=None):
     url = self.url if url_ is None else url_
     try:
         if urlfetch:
             result = urlfetch.fetch(url,
                                     headers=Descargar.std_headers,
                                     deadline=60)
             return result.content
         else:
             return None
     except:
         return Descargar.get(url)
예제 #24
0
    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
예제 #25
0
 def __getQ(self, url):
     # q = self.__get(url)
     q = Descargar.get(url)
     self.debug(unicode(q))
     q = re.findall("BANDWIDTH=([0-9]*).*RESOLUTION=([0-9x]*)|BANDWIDTH=([0-9]*)", q)
     q = [filter(None, n) for n in q]
     qq = []
     for i in q:
         if len(i) < 2:
             i += ("",)
         if i[0] == "1973000":
             tmp = ("2225", i[1])
         else:
             tmp = (str((int(i[0]) / 100000) * 100), i[1])
         qq.append(tmp)
     self.debug(unicode(qq))
     return qq
예제 #26
0
 def __modoNormalVariasPartes(self, streamHTML):
     url2down = []
     name = []
     # Delimitamos la parte del carrusel (funcionará para todos??)
     streamHTML = streamHTML.split("<a title=\"Video Anterior\"")[1].split("<a title=\"Video Siguiente\"")[0]
     partes = len(streamHTML.split("<img title="))-1
     streamPARTES = streamHTML.split("<img title=")[1:]
     self.log(u"[INFO] Número de partes:", str(partes))
     #print streamPARTES
     for i in streamPARTES:
         xmlURL = self.URL_DE_ANTENA3 + i.split("rel=\"/")[1].split("\"")[0]
         streamXML = Descargar.getHtml(xmlURL)
         url2down.append(self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0])
         ext = streamXML.split("<archivo><![CDATA[")[1].split("]")[0].split('.')[-1]
         name.append(i.split("\"")[1].split("\"")[0] + '.' + ext)   
     #print "[INFO] URLs    :",  url2down
     #print "[INFO] Nombres :",  name
     return [url2down, name]
예제 #27
0
 def __getHtmlUrlFromAlacarta(self):
     '''
         Dada una URL de A la Carta de RTVV devuelve su URL normal
     '''
     ID = self.url.split("/")[-1]
     if ID.find("#") == -1 or self.url.endswith("rtvv.es/va/noualacarta/") or \
                                     self.url.endswith("rtvv.es/va/noualacarta"):
         raise Error.GeneralPyspainTVsError(u"Parace que has introducido una URL de 'A la Carta' general, y no específica de un vídeo")
     ID = ID.replace("#", "")
     self.info(u"[INFO] ID:", ID)
     # En versión web frameIDsplit = str(...) ;)
     frameIDsplit = "<li class=\"scr-item contentId_" + ID + "\">"
     self.info(u"[INFO] Separador:", frameIDsplit)
     html = Descargar.get(self.url)
     try:
         frameID = html.split(frameIDsplit.encode('utf8'))[1].split("</li>")[0]
     except Exception, e:
         raise Error.GeneralPyspainTVsError(e)
예제 #28
0
 def geturlfetch(self, url_=None):
     url = self.url if url_ is None else url_
     try:
         if urlfetch:
             result = urlfetch.fetch(url, headers=Descargar.std_headers, deadline=60)
             return result.content
         else:
             return None
     except: return Descargar.get(url)
     
     
 
 
     
     
     
     
     
예제 #29
0
    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
예제 #30
0
    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
예제 #31
0
 def __getHtmlUrlFromAlacarta(self):
     '''
         Dada una URL de A la Carta de RTVV devuelve su URL normal
     '''
     ID = self.url.split("/")[-1]
     if ID.find("#") == -1 or self.url.endswith("rtvv.es/va/noualacarta/") or \
                                     self.url.endswith("rtvv.es/va/noualacarta"):
         raise Error.GeneralPyspainTVsError(
             u"Parace que has introducido una URL de 'A la Carta' general, y no específica de un vídeo"
         )
     ID = ID.replace("#", "")
     self.info(u"[INFO] ID:", ID)
     # En versión web frameIDsplit = str(...) ;)
     frameIDsplit = "<li class=\"scr-item contentId_" + ID + "\">"
     self.info(u"[INFO] Separador:", frameIDsplit)
     html = Descargar.get(self.url)
     try:
         frameID = html.split(
             frameIDsplit.encode('utf8'))[1].split("</li>")[0]
     except Exception, e:
         raise Error.GeneralPyspainTVsError(e)
예제 #32
0
파일: canalsur.py 프로젝트: spds1/PyDownTV2
 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
     }
예제 #33
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)
     '''
     #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)
예제 #34
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)
     '''
     #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)
예제 #35
0
파일: tve.py 프로젝트: chakito/PyDownTV2
    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
                    }
예제 #36
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)
        '''

        # 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
        }
예제 #37
0
파일: cuatro.py 프로젝트: rkmax/PyDownTV2
 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
             }
예제 #38
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
        }
예제 #39
0
파일: plus.py 프로젝트: rkmax/PyDownTV2
    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
        }
예제 #40
0
class TVE(Canal.Canal):
    '''
        Clase para manejar los vídeos de la RTVE (todos).
    '''

    URL_RTVE = "http://rtve.es"

    def __init__(self, url="", opcs=None):
        Canal.Canal.__init__(self, url, opcs, url_validas, __name__)

    # Métodos propios del canal, start the party!
    # Attributos disponibles:
    #    - self.url (url recibida)
    #    - self.opcs (diccionario de opciones) Ver Módulo Canal "_default_opcs" para opciones
    # Métodos disponibles de clase Canal:
    #    - log() para mostrar por pantalla (está disponible si self.opcs["log"] es True)
    #    - self.debug() mostrar información de debug (está disponible si self.opcs["debug"] es True)
    # Comunicación de errores con nivel de aplicación:
    #    - lanzar la excepción: raise Errors.GeneralPyspainTVsError("mensaje")

    def __getSerieName(self, url):
        url = url.split("#/")[1]
        r = [
            n for n in url.split("/")
            if not n.isdigit() and n != "videos" and n != "todos"
        ]
        return r[0] if len(r) == 1 else None

    def __ClanTV(self, html, ID):
        self.info(u"[INFO] Vídeo de Clan")
        logging.debug("entro en clan")
        buscar = self.__getSerieName(self.url)
        logging.debug(buscar)
        if buscar is None:
            #html = Descargar.get(self.url)
            buscar = "/".join(self.url.split("/")[6:9])
            logging.debug(buscar)
            if not buscar.startswith("videos") and not buscar.endswith(
                    "todos"):
                try:
                    serie = Utiles.recortar(self.url, "/videos/", "/todos/")
                    logging.debug(serie)
                except:  #http://www.rtve.es/infantil/videos-juegos/#/videos/suckers/todos/suckers-ventosas/1605449 ó */
                    Surl = self.url.split("/")
                    if Surl[-1] == "": buscar = Surl[-3]
                    if Surl[-1].isdigit(): buscar = Surl[-2]
                    else:
                        raise Error.GeneralPyspainTVsError(
                            u"Error al encontrar la serie. Por favor reporta el error"
                        )
                else:
                    buscar = "/videos/" + serie + "/todos/"
                    logging.debug(buscar)
            buscar = str(buscar)
        self.debug(u"Serie:", buscar)
        logging.debug("final: " + buscar)
        #Ir a la página de descripción de vídeos de Clan
        try:
            dataURL = "http://www.rtve.es/infantil/components/" + html.split(
                buscar)[0].split("<a rel=\"")[-1].split(
                    "\"")[0] + "/videos.xml.inc"
        except Exception, e:
            logging.debug(e.__str__())
        self.debug(u"URL Clan data: " + dataURL)
        logging.debug(dataURL)
        data = Descargar.get(dataURL).split("<video id=\"" +
                                            str(ID))[1].split("</video>")[0]
        logging.debug("tengo data")
        url = self.URL_RTVE + Utiles.recortar(data, "url=\"", "\"")
        logging.debug(url)
        img = Utiles.recortar(data, "url_image=\"", "\"")
        logging.debug(img)
        tit = Utiles.recortar(data, "<title>", "</title>")
        logging.debug(tit)
        name = Utiles.recortar(data, "url_name=\"",
                               "\"") + "." + url.split(".")[-1]
        logging.debug(name)
        desc = Utiles.recortar(data, "<sinopsis>", "</sinopsis>").strip()
        logging.debug(desc)
        if desc == "" or desc == " " or desc == ".":
            desc = u"Vídeo de Clan TV: ".encode('utf8') + Utiles.recortar(
                data, "url_name=\"", "\"")

        return {
            "exito":
            True,
            "num_videos":
            1,
            "mensaje":
            u"URL obtenido correctamente",
            "videos": [{
                "url_video": [url],
                "url_img": img,
                "filename": [name],
                "tipo": "http",
                "partes": 1,
                "rtmpd_cmd": None,
                "menco_cmd": None,
                "url_publi": None,
                "otros": None,
                "mensaje": None
            }],
            "titulos": [tit],
            "descs": [desc] if desc is not None else None
        }
예제 #41
0
파일: tv3.py 프로젝트: rkmax/PyDownTV2
 def __tv8(self):
     html = Descargar.get(self.url)
     VideoPlayer = re.findall(
         "<param.*name=\"@videoPlayer\".*value=\"(.*)\"", html)[0]
     info = self.__get_info(VideoPlayer)
     print info
예제 #42
0
    def __getUrl2down(self, ID, startTime, endTime, html):
        '''
            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
        '''
        self.debug(u"Probando el que era el Método 3")
        tokenizer = self.TOKENIZER
        header = {
            "Referer":
            "http://www.mitele.es/series-online/aida/temporada-10/capitulo-219/",
            "Accept": "*/*",
            "Accept-Language": "es,en;q=0.8",
            "Connection": "keep-alive",
            "User-Agent":
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36",
            "Host": "token.mitele.es"
        }
        server_time = Descargar.get(self.URL_TIME).strip()

        toEncode = (server_time + ";" + ID + ";" + startTime + ";" +
                    endTime).replace(" ", "")
        self.debug("[DEBUG] server_time: %s" % server_time)
        self.debug(u"[DEBUG] toEncode: %s" % toEncode)
        self.debug(
            u"[DEBUG] Util URL: http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s"
            % (toEncode))

        data = Descargar.get(
            "http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s" %
            (toEncode))

        # Datos actuales para el get
        get_args = data + "&id=" + ID.replace(" ",
                                              "") + "&startTime=0&endTime=0"
        # Datos antiguos para el POST
        post_args = {
            'hash': data,
            'id': ID.replace(" ", ""),
            'startTime': '0',
            'endTime': '0'
        }

        self.debug(u"Token: %s" % post_args)

        try:
            header = {
                "Referer":
                "http://static1.tele-cinco.net/comun/swf/playerMitele.swf",
                "Accept":
                "*/*",
                "Origin":
                "http://static1.tele-cinco.net",
                "Connection":
                "keep-alive",
                "User-Agent":
                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36",
                "Accept-Language":
                "de,en;q=0.7,en-us;q=0.3",
                "Content-type":
                "application/x-www-form-urlencoded",
                "Cookie":
                "s_cc=true;s_fid=7B0AC1148C6D6D16-0521A69344CCF613;s_ppv=" +
                self.url + ",49,49,1186;s_sq=[[B]];"
            }
            # Método antiguo, ahora utilizamos GET (guardamos POST para descubrir enlaces de mitele)
            #data = Descargar.doPOST("pydowntv.pydowntv.com", "/pydowntv/mitele2.php", post_args, doseq=True)

            # Devuelve enlaces de Telecinco
            #data = Descargar.get("http://token.mitele.es?hash="+get_args, withHeader=True, header=header)
            #data = Descargar.get("http://pydowntv.pydowntv.com/pydowntv/mitele3.php?url=%s&referer=%s" % (urllib2.quote("http://token.mitele.es?hash="+get_args), urllib2.quote(self.url)))
            data = Descargar.get(
                "http://pydowntv.pydowntv.com/pydowntv/mitele3.php?url=%s&referer=%s"
                % (urllib2.quote("http://token.mitele.es?hash=" + get_args),
                   urllib2.quote(self.url)))

        except Exception, e:
            raise Error.GeneralPyspainTVsError(
                "mitele.es: Error en Tokenizer: " + e.__str__())
예제 #43
0
파일: rtpa.py 프로젝트: rkmax/PyDownTV2
    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
        }
예제 #44
0
파일: crtvg.py 프로젝트: OpenHMR/PyDownTV2
 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
             }
         
         
         
         
         
         
예제 #45
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)
        '''

        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
        }
예제 #46
0
파일: aragontv.py 프로젝트: spds1/PyDownTV2
    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
        }
예제 #47
0
class MiTele(Canal.Canal):
    '''
        Clase para manejar los vídeos de Mi Tele
    '''

    #URL_TIME  = "http://www.mitele.es/media/clock.php"
    #URL_TIME = "http://servicios.telecinco.es/tokenizer/clock.php"
    URL_TIME = "http://token.mitele.es/clock.php"

    #TOKENIZER = "/tokenizer/tk3.php"
    TOKENIZER = "/"

    URL_POST = "token.mitele.es"

    #URL_POST = "servicios.telecinco.es/tokenizer/tkjs.php"

    def __init__(self, url="", opcs=None):
        Canal.Canal.__init__(self, url, opcs, url_validas, __name__)

    def __getUrl2down(self, ID, startTime, endTime, html):
        '''
            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
        '''
        self.debug(u"Probando el que era el Método 3")
        tokenizer = self.TOKENIZER
        header = {
            "Referer":
            "http://www.mitele.es/series-online/aida/temporada-10/capitulo-219/",
            "Accept": "*/*",
            "Accept-Language": "es,en;q=0.8",
            "Connection": "keep-alive",
            "User-Agent":
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36",
            "Host": "token.mitele.es"
        }
        server_time = Descargar.get(self.URL_TIME).strip()

        toEncode = (server_time + ";" + ID + ";" + startTime + ";" +
                    endTime).replace(" ", "")
        self.debug("[DEBUG] server_time: %s" % server_time)
        self.debug(u"[DEBUG] toEncode: %s" % toEncode)
        self.debug(
            u"[DEBUG] Util URL: http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s"
            % (toEncode))

        data = Descargar.get(
            "http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s" %
            (toEncode))

        # Datos actuales para el get
        get_args = data + "&id=" + ID.replace(" ",
                                              "") + "&startTime=0&endTime=0"
        # Datos antiguos para el POST
        post_args = {
            'hash': data,
            'id': ID.replace(" ", ""),
            'startTime': '0',
            'endTime': '0'
        }

        self.debug(u"Token: %s" % post_args)

        try:
            header = {
                "Referer":
                "http://static1.tele-cinco.net/comun/swf/playerMitele.swf",
                "Accept":
                "*/*",
                "Origin":
                "http://static1.tele-cinco.net",
                "Connection":
                "keep-alive",
                "User-Agent":
                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36",
                "Accept-Language":
                "de,en;q=0.7,en-us;q=0.3",
                "Content-type":
                "application/x-www-form-urlencoded",
                "Cookie":
                "s_cc=true;s_fid=7B0AC1148C6D6D16-0521A69344CCF613;s_ppv=" +
                self.url + ",49,49,1186;s_sq=[[B]];"
            }
            # Método antiguo, ahora utilizamos GET (guardamos POST para descubrir enlaces de mitele)
            #data = Descargar.doPOST("pydowntv.pydowntv.com", "/pydowntv/mitele2.php", post_args, doseq=True)

            # Devuelve enlaces de Telecinco
            #data = Descargar.get("http://token.mitele.es?hash="+get_args, withHeader=True, header=header)
            #data = Descargar.get("http://pydowntv.pydowntv.com/pydowntv/mitele3.php?url=%s&referer=%s" % (urllib2.quote("http://token.mitele.es?hash="+get_args), urllib2.quote(self.url)))
            data = Descargar.get(
                "http://pydowntv.pydowntv.com/pydowntv/mitele3.php?url=%s&referer=%s"
                % (urllib2.quote("http://token.mitele.es?hash=" + get_args),
                   urllib2.quote(self.url)))

        except Exception, e:
            raise Error.GeneralPyspainTVsError(
                "mitele.es: Error en Tokenizer: " + e.__str__())

        if data is None:
            return None
        else:
            self.debug("[DEBUG] DATA:\n" + data)
            if data.find("<stream>") != -1 or data.find(
                    "Contenido no reproducible") != -1:
                #self.__mediasetSearch(html) # DEPRECATED

                newData = Descargar.get(
                    "http://www.pydowntv.com/utils/YXRyZXNwbGF5ZXJfcmFuZG9tXzI/%s?method=a"
                    % (toEncode))
                #rtmpinfo = Descargar.doPOST(self.URL_POST, tokenizer, {'hash':newData}, doseq=True)
                rtmpinfo = Descargar.doPOST("pydowntv.pydowntv.com",
                                            "/pydowntv/mitele2.php",
                                            {'hash': newData},
                                            doseq=True)
                self.debug("NEW DATA:\n" + rtmpinfo)

                rtmpinfo = rtmpinfo.replace("&amp;", "&")
                rtmp_r = "\"" + re.findall("\<stream\>(.*?)\<\/stream\>",
                                           rtmpinfo)[0] + "/" + "\""
                rtmp_y = "\"" + re.findall("\<file.*>(.*?)\<\/file\>",
                                           rtmpinfo)[0] + "\""
                rtmp_a = "\"" + rtmp_r.split("/")[-2] + "?" + rtmp_y.split(
                    "?")[1]  #+"\""
                rtmp_u = "\"" + rtmp_y.split("?")[1]  #+"\""
                rtmp_s = "\"" + 'http://static1.tele-cinco.net/comun/swf/playerMitele.swf' + "\""

                url = [
                    rtmp_r, "-y", rtmp_y, "-a", rtmp_a, "-u", rtmp_u, "-s",
                    rtmp_s
                ]
            elif data.find("file") != -1:
                try:
                    url = data.split("<url><file>")[1].split(
                        "</file></url>")[0].replace("&amp;",
                                                    "&").replace(" ", "")
                except IndexError:
                    url = data.split("<file geoblocked=\"true\">")[1].split(
                        "</file></url>")[0].replace("&amp;",
                                                    "&").replace(" ", "")
            elif data.find("tokenizedUrl") != -1:
                url = data.split('"tokenizedUrl":"')[1].split('"')[0].replace(
                    " ", "").replace("\/", "/")
            else:
                print "no entiendo lo que pone"
                return None
            return url
예제 #48
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)
        '''
        
        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
                }
예제 #49
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)
        '''
        #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
        }
예제 #50
0
    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],
        }
예제 #51
0
파일: rtvcyl.py 프로젝트: rkmax/PyDownTV2
    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
        }
예제 #52
0
파일: tv3.py 프로젝트: rkmax/PyDownTV2
    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
        }
예제 #53
0
 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
                 }
예제 #54
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)
     '''
     
     # 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
             }
예제 #55
0
파일: abc.py 프로젝트: ancafe/PyDownTV2
    def getInfo(self):
        '''
            Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
            {
             "exito"     : bool,  <-- True (si se han obtenido videos)
             "num_video" : int,   <-- Número de vídeos obtenidos
             "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
             "videos"    :  [{
                            "url_video" : [],   <-- Url de descarga de vídeo
                            "url_img"   : "",   <-- Url de la miniatura del video
                            "filename"  : [],   <-- Nombre de las partes para guardar en disco
                            "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                            "partes"    : int,  <-- Número de partes que tiene el vídeo
                            "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                            "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                            "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                            "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                            "mensaje"   : ""    <-- Mensajes de la API
                            }], <-- Debe ser una lista de tamaño "num_videos"
             "titulos"   : [u""], <-- Titulos de los videos
             "descs"     : [u""] <-- Descripción de cada vídeo
            }
            
            Los valores que no se rellenen, deberán devolver None.
            La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
            {
            "exito": False,
            "mensaje": "No se pudo descargar el video"  
            }
            
            "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
            "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
        '''
        
        html = Descargar.get(self.url)

        #Por ahora solo soportados para brightcove:
        if not re.findall("ORIGEN[ \=\"\']*([a-zA-Z]*)[ \"\']*;", html)[0] == "bc":
            raise Error.GeneralPyspainTVsError(u'Tipo de vídeo aun no soportado para ABC. Por favor, comunica la incidencia.')

        self.Publisher_ID = re.findall("publisherID=([0-9]*)", html)[0]
        self.Player_ID = re.findall("playerID=([0-9]*)", html)[0]
        VideoPlayer = re.findall("RUTA_VIDEO[ \=\"\']*([0-9]*)[ \"\']*;", html)[0]

        info = self.__get_info(VideoPlayer)
        self.debug(u"info:",info)
        #TODO: Soltar todos los vídeos con las distintas calidades, ahora está solo la de mayor
        big = 0
        for video in info['renditions']:
            if video['encodingRate'] >= big:
                big = video['encodingRate']
                url = video['defaultURL']
        ext = "." + url.split(".")[-1]
        
        try: img = info['videoStillURL']
        except: img = None
        
        desc = None
        try: desc1 = info['longDescription'].encode('utf8') if info['longDescription'] is not None else None
        except: pass
        try: desc2 = info['shortDescription'].encode('utf8') if info['shortDescription'] is not None else None
        except: pass
        try:
            if desc1 is not None: desc = desc1
            else:
                if desc2 is not None: desc = desc2
        except: desc = u"Vídeo de ABC".encode('utf8')
        else:
            if desc is None: desc = u"Vídeo de ABC".encode('utf8')
            else:
                if type(desc) is unicode:
                    if desc == u"": desc = u"Vídeo de ABC".encode('utf8')
                elif type(desc) is str:
                    if desc == "": desc = u"Vídeo de ABC".encode('utf8')
        
        tit = None   
        try: tit = info['displayName'].encode('utf8')
        except: tit = u"Vídeo de ABC".encode('utf8')
        else:
            if tit is None: tit = u"Vídeo de ABC".encode('utf8')
            if type(tit) is unicode:
                if tit == u"": tit = u"Vídeo de ABC".encode('utf8')
            elif type(tit) is str:
                if tit == "": tit = u"Vídeo de ABC".encode('utf8')
        
        #FIXME: Ver qué pasa aquí!! --> name = Utiles.formatearNombre(tit + ext)
        try:
            name = Utiles.formatearNombre2(tit+ext)
        except:
            name = "VideoABC"+ext
        
        # Parece que NO funciona lo siguiente para ABC, solo para Telemadrid
        #url = "/".join(img.split("/")[:3])+"/"+"/".join(url.split("/")[3:])
        rtmpd_cmd = "rtmpdump -r '"+url.replace("&mp4:","mp4/")+"' -o '"+name+"'"

        
        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [url.replace("&mp4:","mp4/")],
                        "url_img"   : img if img is not None else None,
                        "filename"  : [name] if name is not None else None,
                        "tipo"      : "rtmp",
                        "partes"    : 1,
                        "rtmpd_cmd" : [rtmpd_cmd],
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [tit] if tit is not None else None,
                "descs": [desc] if desc is not None else None
                }
예제 #56
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)
        '''
        
        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
                }
예제 #57
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)
        '''

        # 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
        }
예제 #58
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)
        '''
        
        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
                }