Python tmdb.Tmdb类代码示例

def findvideos(item):
    logger.info("[pelisadicto.py] findvideos")

    itemlist = []

    data = scrapertools.cache_page(item.url)

    data = scrapertools.unescape(data)

    titulo = item.title
    titulo_tmdb = re.sub("([0-9+])", "", titulo.strip())

    oTmdb= Tmdb(texto_buscado=titulo_tmdb, idioma_busqueda="es")
    item.fanart=oTmdb.get_backdrop()

    # Descarga la pagina
#    data = scrapertools.cache_page(item.url)
    patron = '#div_\d_\D.+?<img id="([^"]+).*?<span>.*?</span>.*?<span>(.*?)</span>.*?imgdes.*?imgdes/([^\.]+).*?<a href=([^\s]+)'  #Añado calidad
    matches = re.compile(patron,re.DOTALL).findall(data)
    for scrapedidioma, scrapedcalidad, scrapedserver, scrapedurl in matches:

        title = titulo + "_" + scrapedidioma + "_"+ scrapedserver + "_" + scrapedcalidad
        itemlist.append( Item(channel=__channel__, action="play", title=title, fulltitle=title, url=scrapedurl, thumbnail=item.thumbnail, plot=item.plot, show=item.show, fanart=item.fanart) )

    return itemlist

def get_only_episodio(item):
    logger.info("[pepecine.py] get_only_episodio")
    itemlist = []
    plot={}
    
    data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)","",scrapertools.cache_page(item.url))
    patron ='vars.title =(.*?)};'
    try:
        data_dict= jsontools.load_json(scrapertools.get_match(data,patron) +'}')
    except:
        return itemlist # Devolvemos lista vacia
        
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(id_Tmdb= data_dict['tmdb_id'],tipo="tv")
    except:
        pass

    infoLabels = item.infoLabels
    cast=[]
    rol=[]
    for actor in data_dict["actor"]:
        cast.append(actor['name'])
        rol.append(actor['pivot']['char_name'])
    
    writers_list=[]
    for writer in data_dict["writer"]:
        writers_list.append(writer['name'])
        
    director_list=[]
    for director in data_dict["director"]:
        director_list.append(director['name'])    
    
    infoLabels['cast'] = cast
    infoLabels['castandrole'] = zip(cast,rol)
    infoLabels['writer'] = ", ".join(writers_list )
    infoLabels['director'] = ", ".join(director_list )
    infoLabels['season'], infoLabels['episode']= item.extra.split('x')
    try:
        # añadimos sinopsis e imagenes del capitulo
        datos_tmdb=oTmdb.get_episodio(temporada= infoLabels['season'],capitulo= infoLabels['episode'])
        if datos_tmdb["episodio_sinopsis"] !="": infoLabels['plot']= datos_tmdb["episodio_sinopsis"]
        if datos_tmdb["episodio_imagen"] !="": item.thumbnail= datos_tmdb["episodio_imagen"]
        #if datos_tmdb["episodio_titulo"] !="": title = title + " [COLOR 0xFFFFE6CC]" + datos_tmdb["episodio_titulo"].replace('\t','') + "[/COLOR]"
    except:
            pass
    
    def cap(l): 
        try:
            temporada_link = int(l["season"])
            capitulo_link = int(l['episode'])
        except:
            return False
        return True if temporada_link== int(infoLabels['season'])  and capitulo_link == int(infoLabels['episode']) else False    
    item.url= str(filter(cap, data_dict["link"])) #filtramos enlaces por capitulo

    item.infoLabels = infoLabels
    item.extra=str(data_dict['tmdb_id'])
    
    return findvideos(item)

    def get_tmdb_tv_data(self, text, season=0, episode=0):
        # Pasamos la temporada y episodeo a int()
        season = int(season)
        episode = int(episode)

        # Buscamos la serie si no esta cargada
        if not self.otmdb:
            self.otmdb = Tmdb(texto_buscado=text, idioma_busqueda="es", tipo="tv")

        _id = self.otmdb.get_id()

        # Si no hay resultados salimos
        if not _id:
            return False

        # informacion generica de la serie
        self.result["type"] = "tv"
        self.result["id_Tmdb"] = self.otmdb.get_id()
        self.result["title"] = self.otmdb.result.get("name", "N/A")
        self.result["rating"] = self.otmdb.result["vote_average"] + "/10 (" + self.otmdb.result["vote_count"] + ")"
        self.result["genres"] = ", ".join(self.otmdb.result["genres"])
        self.result["language"] = self.get_language(self.otmdb.result["original_language"])
        self.result["thumbnail"] = self.otmdb.get_poster()
        self.result["fanart"] = self.otmdb.get_backdrop()
        self.result["overview"] = self.otmdb.result.get("overview", "N/A")

        # Si tenemos informacion de temporada y episodio
        if season and episode:
            if "seasons" not in self.result or self.result["seasons"] == "":
                self.otmdb = Tmdb(id_Tmdb=id, idioma_busqueda="es", tipo="tv")
                self.result["seasons"] = str(self.otmdb.result.get("number_of_seasons", 0))

            if season > self.result["seasons"]:
                season = self.result["season_count"]

            if episode > self.otmdb.result.get("seasons")[season-1]["episode_count"]:
                episode = self.otmdb.result.get("seasons")[season]["episode_count"]

            # Solicitamos información del episodio concreto
            episode_info = self.otmdb.get_episodio(season, episode)

            # informacion de la temporada
            self.result["season"] = str(season)
            if episode_info.get("temporada_poster"):
                self.result["thumbnail"] = episode_info.get("temporada_poster")
            if self.otmdb.result.get("overview"):
                self.result["overview"] = self.otmdb.result.get("overview")

            # informacion del episodio
            self.result["episode"] = str(episode)
            self.result["episodes"] = str(episode_info.get('temporada_num_episodios', 0))
            self.result["episode_title"] = episode_info.get("episodio_titulo", "N/A")
            self.result["date"] = self.get_date(self.otmdb.temporada[season]["episodes"][episode-1].get("air_date"))
            if episode_info.get("episodio_imagen"):
                self.result["fanart"] = episode_info.get("episodio_imagen")
            if episode_info.get("episodio_sinopsis"):
                self.result["overview"] = episode_info.get("episodio_sinopsis")

        return True

    def get_tmdb_tv_data(self, text):
        # Buscamos la serie si no esta cargada
        if not self.otmdb:
            self.otmdb = Tmdb(texto_buscado=text, idioma_busqueda="es", tipo="tv")

        # Si no hay resultados salimos
        if not self.otmdb.get_id():
            return False

        # informacion generica de la serie
        infoLabels = self.otmdb.get_infoLabels()
        infoLabels["mediatype"] = "tvshow"
        infoLabels["language"] = self.get_language(infoLabels["original_language"])
        infoLabels["puntuacion"] = str(infoLabels["rating"]) + "/10 (" + str(infoLabels["votes"]) + ")"

        self.result = infoLabels

        # Si tenemos informacion de temporada
        if self.item_temporada:
            if not self.result["seasons"]:
                self.otmdb = Tmdb(id_Tmdb=infoLabels["tmdb_id"], idioma_busqueda="es", tipo="tv")
                # logger.debug(str(self.otmdb.get_infoLabels()))

                self.result["seasons"] = str(self.otmdb.result.get("number_of_seasons", 0))

            if self.item_temporada > self.result["seasons"]:
                self.item_temporada = self.result["season_count"]

            if self.item_episodio > self.otmdb.result.get("seasons")[self.item_temporada - 1]["episode_count"]:
                self.item_episodio = self.otmdb.result.get("seasons")[self.item_temporada]["episode_count"]

            # Solicitamos información del episodio concreto
            episode_info = self.otmdb.get_episodio(self.item_temporada, self.item_episodio)

            # informacion de la temporada
            self.result["season"] = str(self.item_temporada)
            self.result["temporada_nombre"] = episode_info.get("temporada_nombre", "N/A")
            self.result["episodes"] = str(episode_info.get("temporada_num_episodios", "N/A"))
            if episode_info.get("temporada_poster"):
                self.result["thumbnail"] = episode_info.get("temporada_poster")
            if episode_info.get("temporada_sinopsis"):
                self.result["plot"] = episode_info.get("temporada_sinopsis")

            # Si tenemos numero de episodio:
            if self.item_episodio:
                # informacion del episodio
                self.result["episode"] = str(self.item_episodio)
                self.result["episode_title"] = episode_info.get("episodio_titulo", "N/A")
                self.result["date"] = self.get_date(
                    self.otmdb.temporada[self.item_temporada]["episodes"][self.item_episodio - 1].get("air_date")
                )
                if episode_info.get("episodio_imagen"):
                    self.result["fanart"] = episode_info.get("episodio_imagen")
                if episode_info.get("episodio_sinopsis"):
                    self.result["plot"] = episode_info.get("episodio_sinopsis")

        return True

def tmdb(item):
    from core.tmdb import Tmdb
    #oTmdb= Tmdb(id_Tmdb='1399',tipo='tv')
    #print oTmdb.get_poster(rnd= True, size="w185")
    #oTmdb= Tmdb(texto_buscado='juego de tronos',tipo='tv')
    oTmdb= Tmdb(external_id='121361',tipo='tv',external_source="tvdb_id")
    print "id: " + oTmdb.get_id()
    #print oTmdb.get_episodio(2,5)
    #print oTmdb.get_episodio(2,1)
    print oTmdb.get_sinopsis()

def get_episodios(item):
    logger.info("[pepecine.py] get_episodios")
    itemlist = []
    plot={}
    
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(id_Tmdb= item.extra,tipo="tv")
    except:
        pass
    
    infoLabels=get_infoLabels(item)

    lista_links=ast.literal_eval(item.url) 
    # Agrupar enlaces por episodios  temXcap
    temXcap_dict={}
    for link in lista_links:
        title_id = link['id']
        id= str(link['season']) + "x" + str(link['episode']).zfill(2)
        if temXcap_dict.has_key(id):
            l= temXcap_dict[id]
            l.append(link)
            temXcap_dict[id]= l
        else:
            temXcap_dict[id]= [link]
            
    # Ordenar lista de enlaces por temporada y capitulo
    temXcap_list=temXcap_dict.items()
    temXcap_list.sort(key=lambda x: (int(x[0].split("x")[0]),int(x[0].split("x")[1])))
    for episodio in temXcap_list:
        title= '[COLOR 0xFF994D00]' + infoLabels['titleraw'] + '[/COLOR] [COLOR 0xFFFFCE9C](' + episodio[0] + ')[/COLOR]'
        infoLabels['season'], infoLabels['episode']=  episodio[0].split('x')
        try:
            # añadimos sinopsis e imagenes para cada capitulo
            datos_tmdb=oTmdb.get_episodio(temporada= infoLabels['season'],capitulo= infoLabels['episode'])
            if datos_tmdb["episodio_sinopsis"] !="": infoLabels['plot']= datos_tmdb["episodio_sinopsis"]
            if datos_tmdb["episodio_imagen"] !="": item.thumbnail= datos_tmdb["episodio_imagen"]
            if datos_tmdb["episodio_titulo"] !="": title = title + " [COLOR 0xFFFFE6CC]" + datos_tmdb["episodio_titulo"].replace('\t','') + "[/COLOR]"
        except:
                pass
        
        if infoLabels.has_key("plot"):
            plot['infoLabels']= infoLabels
            item.plot = str(plot)
        itemlist.append( myItem( channel=__channel__, action="findvideos", title=title, url=str(episodio[1]), extra=item.extra, show=infoLabels['tvshowtitle'], fanart=item.fanart, plot=item.plot, thumbnail=item.thumbnail, viewmode="movie_with_plot") )
    
    if config.get_library_support() and itemlist:
        url= urlparse.urljoin(__url_base__,"series-online/" + str(title_id))
        #url= urlparse.urljoin(__url_base__,"series-online/" + (str(infoLabels['title_id']) +"-"+ infoLabels['titleraw']))
        itemlist.append( myItem(channel=__channel__, title="[COLOR 0xFFe5ffcc]Añadir esta serie a la biblioteca[/COLOR]", url=url, action="add_serie_to_library", extra='episodios###serie_add', show= infoLabels['tvshowtitle'], thumbnail = 'https://d5.usercdn.com/dl/i/02360/a99fzwbqdaen.png'))

    
    return itemlist

def show_movie_info(item):
    logger.info("pelisalacarta.mejortorrent show_movie_info")

    itemlist = []

    tmdb_title = re.sub(r"\(.*\)|\[.*\]", "", item.title).strip()
    logger.debug("pelisalacarta.mejortorrent show_movie_info tmdb_title=" + tmdb_title)

    try:
        oTmdb = Tmdb(texto_buscado=tmdb_title, idioma_busqueda="es")
        item.fanart = oTmdb.get_backdrop()
        item.plot = oTmdb.get_sinopsis()
    except:
        pass

    data = scrapertools.cache_page(item.url)
    logger.debug("data=" + data)

    patron = "<a href='(secciones.php\?sec\=descargas[^']+)'"
    matches = re.compile(patron, re.DOTALL).findall(data)
    scrapertools.printMatches(matches)

    for scrapedurl in matches:
        url = urlparse.urljoin(item.url, scrapedurl)
        logger.debug("title=[" + item.title + "], url=[" + url + "], thumbnail=[" + item.thumbnail + "]")

        torrent_data = scrapertools.cache_page(url)
        logger.debug("torrent_data=" + torrent_data)
        # <a href='/uploads/torrents/peliculas/los-juegos-del-hambre-brrip.torrent'>
        link = scrapertools.get_match(torrent_data, "<a href='(/uploads/torrents/peliculas/.*?\.torrent)'>")
        link = urlparse.urljoin(url, link)

        logger.debug("link=" + link)

        itemlist.append(
            Item(
                channel=__channel__,
                action="play",
                server="torrent",
                title=item.title,
                url=link,
                thumbnail=item.thumbnail,
                plot=item.plot,
                fanart=item.fanart,
                folder=False,
                viewmode="movie_with_plot",
            )
        )

    return itemlist

def info(title, thumbnail):
    logger.info("streamondemand.eurostreaminginfo info")
    infoLabels={}
    plot={}
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(texto_buscado=title, tipo= "movie")
        count = 0
        if oTmdb.total_results > 0:
            #Mientras el thumbnail no coincida con el del resultado de la búsqueda, pasa al siguiente resultado
            while oTmdb.get_poster(size="w185") != thumbnail:
                count += 1
                oTmdb.load_resultado(index_resultado=count)
                if count == oTmdb.total_results : break
            infoLabels['code'] = oTmdb.get_id()
            infoLabels['plot'] = oTmdb.get_sinopsis()
            infoLabels['title'] = oTmdb.result["title"]
            infoLabels['year']= oTmdb.result["release_date"][:4]
            infoLabels['genre'] = ", ".join(oTmdb.result["genres"])
            infoLabels['rating'] = float(oTmdb.result["vote_average"])
            fanart=oTmdb.get_backdrop()
            poster=oTmdb.get_poster()
            plot['infoLabels']=infoLabels
            return plot, fanart, poster
    except:
        pass	

def info_tv(title):
    logger.info("streamondemand.cineblog01 info")
    try:
        from core.tmdb import Tmdb
        oTmdb = Tmdb(texto_buscado=title, tipo="tv", include_adult="false", idioma_busqueda="it")
        if oTmdb.total_results > 0:
            extrameta = {"Year": oTmdb.result["release_date"][:4],
                         "Genre": ", ".join(oTmdb.result["genres"]),
                         "Rating": float(oTmdb.result["vote_average"])}
            fanart = oTmdb.get_backdrop()
            poster = oTmdb.get_poster()
            plot = oTmdb.get_sinopsis()
            return plot, fanart, poster, extrameta
    except:
        pass

def info(title, type, sinopsis):
    logger.info("pelisalacarta.descargasmix info")
    infolabels={}
    plot={}
    try:
        from core.tmdb import Tmdb
        otmdb= Tmdb(texto_buscado=title, tipo= type)
        if otmdb.get_sinopsis() == "": infolabels['plot'] = sinopsis
        else: infolabels['plot'] = otmdb.get_sinopsis()
        infolabels['year']= otmdb.result["release_date"][:4]
        infolabels['genre'] = otmdb.get_generos()
        infolabels['rating'] = float(otmdb.result["vote_average"])
        fanart=otmdb.get_backdrop()
        plot['infoLabels']=infolabels
        return plot, fanart
    except:
        pass

def info(title):
    logger.info("streamondemand.italianstream info")
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(texto_buscado=title, tipo= "movie", include_adult="true", idioma_busqueda="it")
        count = 0
        if oTmdb.total_results > 0:
           extrameta = {}
           extrameta["Year"] = oTmdb.result["release_date"][:4]
           extrameta["Genre"] = ", ".join(oTmdb.result["genres"])
           extrameta["Rating"] = float(oTmdb.result["vote_average"])
           fanart=oTmdb.get_backdrop()
           poster=oTmdb.get_poster()
           plot=oTmdb.get_sinopsis()
           return plot, fanart, poster, extrameta
    except:
        pass	

def tmdb_trailers(item, tipo="movie"):
    logger.info("streamondemand.channels.trailertools tmdb_trailers")

    from core.tmdb import Tmdb
    itemlist = []
    tmdb_search = None
    if item.infoLabels['tmdb_id']:
        tmdb_search = Tmdb(id_Tmdb=item.infoLabels['tmdb_id'], tipo=tipo, idioma_busqueda='it')
    elif item.infoLabels['year']:
        tmdb_search = Tmdb(texto_buscado=item.contentTitle, tipo=tipo, year=item.infoLabels['year'])

    if tmdb_search:
        for result in tmdb_search.get_videos():
            title = result['name'] + " [" + result['size'] + "p] (" + result['language'].replace("en", "ING")\
                    .replace("es", "ESP")+")  [tmdb/youtube]"
            itemlist.append(item.clone(action="play", title=title, url=result['url'], server="youtube"))
    
    return itemlist

def info(title):
    logger.info("streamondemand.corsaronero info")
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(texto_buscado=title, tipo="movie", include_adult="false", idioma_busqueda="it")
        count = 0
        if oTmdb.total_results > 0:
            #Mientras el thumbnail no coincida con el del resultado de la búsqueda, pasa al siguiente resultado
            #while oTmdb.get_poster(size="w185") != thumbnail:
                #count += 1
                #oTmdb.load_resultado(index_resultado=count)
                #if count == oTmdb.total_results : break
           extrameta = {}
           extrameta["Year"] = oTmdb.result["release_date"][:4]
           extrameta["Genre"] = ", ".join(oTmdb.result["genres"])
           extrameta["Rating"] = float(oTmdb.result["vote_average"])
           fanart=oTmdb.get_backdrop()
           poster=oTmdb.get_poster()
           plot=oTmdb.get_sinopsis()
           return plot, fanart, poster, extrameta
    except:
        pass	

def completar_codigos(item):
    """
    Si es necesario comprueba si existe el identificador de tmdb y sino existe trata de buscarlo
    @param item: tipo item
    @type item: Item
    """
    if not item.infoLabels['tmdb_id']:
        listsources = [(item.infoLabels['tvdb_id'], "tvdb_id")]
        if item.infoLabels['imdb_id']:
            listsources.append((item.infoLabels['imdb_id'], "imdb_id"))

        from core.tmdb import Tmdb
        ob = Tmdb()

        for external_id, external_source in listsources:
            ob.search_by_id(id=external_id, source=external_source, tipo='tv')

            item.infoLabels['tmdb_id'] = ob.get_id()
            if item.infoLabels['tmdb_id']:
                url_scraper = "https://www.themoviedb.org/tv/%s" % item.infoLabels['tmdb_id']
                item.infoLabels['url_scraper'].append(url_scraper)
                break

    def get_tmdb_movie_data(self, text):
        # Buscamos la pelicula si no lo esta ya
        if not self.otmdb:
            self.otmdb = Tmdb(texto_buscado=text, idioma_busqueda="es", tipo="movie")

        # Si no hay resultados salimos
        if not self.otmdb.get_id():
            return False

        # Informacion de la pelicula
        infoLabels = self.otmdb.get_infoLabels()
        infoLabels["mediatype"] = "movie"
        infoLabels["language"] = self.get_language(infoLabels["original_language"])
        infoLabels["puntuacion"] = str(infoLabels["rating"]) + "/10 (" + str(infoLabels["votes"]) + ")"

        self.result = infoLabels

        return True