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)
Exemple #2
0
def info(title):
    logger.info("streamondemand.scambioetico 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
Exemple #3
0
def tmdb_trailers(item, dialog, tipo="movie"):
    logger.debug()

    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, search_language=def_lang)
    elif item.infoLabels['year']:
        tmdb_search = Tmdb(searched_text=item.contentTitle, tipo=tipo, year=item.infoLabels['year'])

    if tmdb_search:
        found = False
        for vid in tmdb_search.get_videos():
            if vid['type'].lower() == 'trailer':
                title = vid['name']
                it = del_id(item.clone(action="play", title=title, title2="TMDB(youtube) - " + vid['language'].replace("en", "ING").replace("it", "ITA") + " [" + vid['size'] + "p]", url=vid['url'], server="youtube"))
                itemlist.append(it)

                if vid['language'] == def_lang and not found:  # play now because lang is correct and TMDB is trusted
                    found = True
                    launcher.run(it)
                    dialog.close()
                    while platformtools.is_playing():
                        xbmc.sleep(100)

    return itemlist
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
Exemple #5
0
def tmdb_trailers(item, tipo="movie"):
    logger.debug()

    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=def_lang)
    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(
                    "it", "ITA") + ")  [tmdb/youtube]"
            itemlist.append(
                item.clone(action="play",
                           title=title,
                           url=result['url'],
                           server="youtube"))

    return itemlist
    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="it",
                              tipo="movie")

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

        # Informacion de la pelicula
        self.result["type"] = "movie"
        self.result["tmdb_id"] = self.otmdb.get_id()
        self.result["title"] = self.otmdb.result["title"]
        self.result["original_title"] = self.otmdb.result["original_title"]
        self.result["date"] = self.get_date(self.otmdb.result["release_date"])
        self.result["language"] = self.get_language(
            self.otmdb.result["original_language"])
        self.result["rating"] = self.otmdb.result[
            "vote_average"] + "/10 (" + self.otmdb.result["vote_count"] + ")"
        self.result["genres"] = ", ".join(self.otmdb.result["genres"])
        self.result["thumbnail"] = self.otmdb.get_poster()
        self.result["fanart"] = self.otmdb.get_backdrop()
        self.result["overview"] = self.otmdb.result["overview"]

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

    from core.tmdb import Tmdb
    itemlist = []
    tmdb_search = None
    if "tmdb_id" in item.infoLabels and item.infoLabels['tmdb_id'] != "":
        tmdb_search = Tmdb(id_Tmdb=item.infoLabels['tmdb_id'],
                           tipo=type,
                           idioma_busqueda='it')
    elif "year" in item.infoLabels and item.infoLabels['year'] != "":
        tmdb_search = Tmdb(texto_buscado=item.contentTitle,
                           tipo=type,
                           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
Exemple #8
0
def get_episodios(item):
    logger.info()
    itemlist = []
    plot={}
    
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(id_Tmdb= item.extra,tipo="tv")
    except:
        pass

    infoLabels = item.infoLabels

    lista_links=ast.literal_eval(item.url) 
    # Agrupar enlaces por episodios  temXcap
    temXcap_dict={}
    for link in lista_links:
        title_id = link['title_id']
        try:
            season = str(int(link['season']))
            episode = str(int(link['episode'])).zfill(2)
        except:
            continue
        id= season + "x" + episode
        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= infoLabels['titleraw'] + ' (' + episodio[0] + ')'
        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 + " " + datos_tmdb["episodio_titulo"].replace('\t','')
        except:
                pass

        itemlist.append( Item( channel=item.channel, action="findvideos", title=title, url=str(episodio[1]),
                               extra=item.extra, show=infoLabels['tvshowtitle'], fanart=item.fanart,
                               infoLabels = infoLabels,
                               thumbnail=item.thumbnail, viewmode="movie_with_plot", text_color="0xFFFFCE9C") )
    
    if config.get_library_support() and itemlist:
        url= urlparse.urljoin(__url_base__,"episodio-online/" + str(title_id))
        itemlist.append( Item(channel=item.channel, title="Añadir esta serie a la biblioteca", url=url,
                              text_color="0xFFe5ffcc", action="add_serie_to_library", extra='episodios###serie_add',
                              show= infoLabels['tvshowtitle'],
                              thumbnail = 'https://raw.githubusercontent.com/master-1970/resources/master/images/channels/pepecine/tv.png'))

    
    return itemlist
Exemple #9
0
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=item.channel,
                 action="play",
                 title=title,
                 fulltitle=title,
                 url=scrapedurl,
                 thumbnail=item.thumbnail,
                 plot=item.plot,
                 show=item.show,
                 fanart=item.fanart))

    return itemlist
Exemple #10
0
def show_movie_info(item):
    logger.info()

    itemlist = []

    tmdb_title = re.sub(r'\(.*\)|\[.*\]', '', item.title).strip()
    logger.debug('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 = httptools.downloadpage(item.url).data

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

    for scrapedurl in matches:
        url = urlparse.urljoin(item.url, scrapedurl)
        logger.debug("title=[" + item.title + "], url=[" + url + "], thumbnail=[" + item.thumbnail + "]")
        torrent_data = httptools.downloadpage(url).data
        if scrapertools.find_single_match(torrent_data, "<a href='(\/uploads\/torrents\/peliculas\/.*?\.torrent)'>"):
            link = scrapertools.get_match(torrent_data, "<a href='(\/uploads\/torrents\/peliculas\/.*?\.torrent)'>")
        else:
            link = scrapertools.get_match(torrent_data, "<a href='(http:\/\/www.mejortorrent.com\/uploads\/torrents\/.*?peliculas\/.*?\.torrent)'>")
        link = urlparse.urljoin(url, link)
        logger.debug("link=" + link)
        itemlist.append(Item(channel=item.channel, action="play", server="torrent", title=item.title, url=link,
                             thumbnail=item.thumbnail, plot=item.plot, fanart=item.fanart, folder=False, extra="pelicula"))

    return itemlist
    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
Exemple #12
0
    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["tmdb_id"] = 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()
Exemple #15
0
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
Exemple #16
0
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 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	
Exemple #19
0
def info(title, thumbnail):
    logger.info("pelisalacarta.inkapelis 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()
            plot['infoLabels'] = infoLabels
            return plot, fanart
    except:
        pass
def info_tv(title, year):
    logger.info("streamondemand.cinemalibero info")
    try:
        from core.tmdb import Tmdb
        oTmdb = Tmdb(texto_buscado=title, year=year, 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_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):
    logger.info("streamondemand.cinemalibero 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:
            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 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 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 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
Exemple #26
0
def episodios(item):
    logger.info("pelisalacarta.channels.descargasmix episodios")
    itemlist = []
    fanart = item.fanart
    thumbnail = item.thumbnail
    try:
        from core.tmdb import Tmdb
        otmdb = Tmdb(texto_buscado=item.fulltitle, tipo="tv")
    except:
        pass
    data = scrapertools.cachePage(item.url)
    patron = item.title + '(.*?)</li>'
    bloque = scrapertools.find_single_match(data, patron)
    patron = '<h3 style="text-transform: uppercase;font-size: 18px;">(.*?)</h3>'
    matches = scrapertools.find_multiple_matches(bloque, patron)
    for scrapedtitle in matches:
        try:
            if "Descargar" in scrapedtitle:
                titulo = "[COLOR sandybrown][B]" + scrapedtitle + "[/B][/COLOR]"
                item.plot, fanart, thumbnail = infoepi(
                    otmdb,
                    scrapedtitle.rsplit(' ', 1)[1])
            else:
                titulo = "[COLOR green][B]" + scrapedtitle + "[/B][/COLOR]"
                item.plot, fanart, thumbnail = infoepi(
                    otmdb,
                    scrapedtitle.rsplit(' ', 1)[1])
        except:
            pass
        try:
            fulltitle = item.fulltitle + match.split(item.fulltitle)[1]
            itemlist.append(
                Item(channel=__channel__,
                     action="epienlaces",
                     title=titulo,
                     fulltitle=fulltitle,
                     url=item.url,
                     thumbnail=thumbnail,
                     fanart=fanart,
                     plot=str(item.plot),
                     context="2",
                     extra=scrapedtitle,
                     folder=True))
        except:
            itemlist.append(
                Item(channel=__channel__,
                     action="epienlaces",
                     title=titulo,
                     fulltitle=item.fulltitle,
                     url=item.url,
                     thumbnail=thumbnail,
                     fanart=fanart,
                     plot=str(item.plot),
                     context="2",
                     extra=scrapedtitle,
                     folder=True))
    return itemlist
Exemple #27
0
def completar_codigos(item):
    """
    If necessary, check if the tmdb identifier exists and if it does not exist try to find it
    @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 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 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
Exemple #30
0
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
Exemple #31
0
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
Exemple #32
0
def episodios(item):
    logger.info("pelisalacarta.channels.descargasmix episodios")
    itemlist = []
    fanart = item.fanart
    thumbnail = item.thumbnail
    if item.category == "":
        try:
            from core.tmdb import Tmdb
            otmdb = Tmdb(texto_buscado=item.fulltitle, tipo="tv")
        except:
            pass
    data = scrapertools.cachePage(item.url)
    patron = '(<ul class="menu" id="seasons-list">.*?<div class="section-box related-posts">)'
    bloque = scrapertools.find_single_match(data, patron)
    patron = '<strong>(.*?)</strong>'
    matches = scrapertools.find_multiple_matches(bloque, patron)
    for scrapedtitle in matches:
        if item.category == "":
            try:
                item.plot, fanart, thumbnail = infoepi(otmdb, scrapedtitle)
            except:
                pass
        scrapedtitle = item.fulltitle + " " + scrapedtitle.strip()
        itemlist.append(
            Item(channel=__channel__,
                 action="epienlaces",
                 title=scrapedtitle,
                 fulltitle=item.fulltitle,
                 url=item.url,
                 thumbnail=thumbnail,
                 fanart=fanart,
                 plot=str(item.plot),
                 context="2",
                 contentTitle=item.fulltitle,
                 show=item.fulltitle,
                 folder=True))

    itemlist.sort(key=lambda item: item.title, reverse=True)

    if config.get_library_support():
        itemlist.append(
            Item(
                channel=__channel__,
                title="[COLOR green]Añadir esta serie a la biblioteca[/COLOR]",
                url=item.url,
                action="add_serie_to_library",
                extra="episodios",
                fulltitle=item.fulltitle,
                show=item.fulltitle))
    return itemlist
    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
Exemple #34
0
def info(title):
    logger.info("pelisalacarta.verseriesynovelas info")
    infolabels = {}
    plot = {}
    try:
        from core.tmdb import Tmdb
        otmdb = Tmdb(texto_buscado=title, tipo="tv")
        infolabels['plot'] = otmdb.get_sinopsis()
        infolabels['year'] = otmdb.result["release_date"][:4]
        infolabels['genre'] = otmdb.get_generos()
        infolabels['rating'] = float(otmdb.result["vote_average"])
        if otmdb.get_poster() != "": thumbnail = otmdb.get_poster()
        else: thumbnail = ""
        fanart = otmdb.get_backdrop()
        plot['infoLabels'] = infolabels
        return plot, fanart, thumbnail
    except:
        pass
Exemple #35
0
def info(title, type, sinopsis):
    logger.info("pelisalacarta.allpeliculas 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 get_tmdb_data(self, data_in):
        self.otmdb = None
        #logger.debug(str(data_in))

        if self.listData:
            infoLabels = InfoLabels()

            # Datos comunes a todos los listados
            infoLabels = Tmdb().get_infoLabels(infoLabels=infoLabels,
                                               origen=data_in)
            infoLabels["language"] = self.get_language(
                infoLabels["original_language"])
            infoLabels["puntuacion"] = str(
                data_in["vote_average"]) + "/10 (" + str(
                    data_in["vote_count"]) + ")"

            self.from_tmdb = False
            self.result = infoLabels

        else:
            if isinstance(data_in, Item):
                self.from_tmdb = True
                self.get_item_info(data_in)

                # Modo Pelicula
                if not self.item_serie:
                    encontrado = self.get_tmdb_movie_data(self.item_title)
                    if not encontrado:
                        encontrado = self.get_tmdb_tv_data(self.item_title)

                else:
                    encontrado = self.get_tmdb_tv_data(self.item_serie)
                    if not encontrado:
                        encontrado = self.get_tmdb_movie_data(self.item_serie)

            if isinstance(data_in, dict):
                self.from_tmdb = False
                self.result = InfoLabels(data_in)
    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
        self.result["type"] = "movie"
        self.result["id_Tmdb"] = self.otmdb.get_id()
        self.result["title"] = self.otmdb.result["title"]
        self.result["original_title"] = self.otmdb.result["original_title"]
        self.result["date"] = self.get_date(self.otmdb.result["release_date"])
        self.result["language"] = self.get_language(self.otmdb.result["original_language"])
        self.result["rating"] = self.otmdb.result["vote_average"] + "/10 (" + self.otmdb.result["vote_count"] + ")"
        self.result["genres"] = ", ".join(self.otmdb.result["genres"])
        self.result["thumbnail"] = self.otmdb.get_poster()
        self.result["fanart"] = self.otmdb.get_backdrop()
        self.result["overview"] = self.otmdb.result["overview"]

        return True
Exemple #38
0
def info(title, year=""):
    logger.info("pelisalacarta.cultmoviez info")
    infolabels={}
    plot={}
    try:
        from core.tmdb import Tmdb
        otmdb= Tmdb(texto_buscado=title, tipo= "movie", year=year)
        infolabels['plot'] = otmdb.get_sinopsis()
        infolabels['year']= otmdb.result["release_date"][:4]
        infolabels['genre'] = otmdb.get_generos()
        infolabels['rating'] = float(otmdb.result["vote_average"])
        if otmdb.get_poster() != "": thumbnail = otmdb.get_poster()
        else: thumbnail = ""
        fanart=otmdb.get_backdrop()
        plot['infoLabels']=infolabels
        return plot, fanart, thumbnail
    except:
        pass
Exemple #39
0
def findvideos(item):
    logger.info("[peliserie.py] findvideos extra: " + item.extra)
    itemlist=[]
    
    if item.extra=='peliculas':
        # Solo mostramos enlaces para ver online
        patron= 'id="contribution-view">(.*?)</ul>'
        # Si quisiseramos mostrarlos todos: patron= 'id="contribution-view">(.*?)class="list-end"'
        
        # Buscamos el fanart en TMDB
        year=item.show.split('|')[1]
        item.show = item.show.split('|')[0]
        try:
            from core.tmdb import Tmdb
            oTmdb= Tmdb(texto_buscado=item.show,year=year)
            item.fanart=oTmdb.get_backdrop()
        except:
            pass
        
        
    else: # 'series' y 'play_from_library'
        # Solo mostramos enlaces para ver online
        patron= 'id="view-list">(.*?)</ul>'
        # Si quisiseramos mostrarlos todos: patron= 'id="id="view-list">(.*?)class="list-end"'
    
    
    # Descarga la página
    data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)","",scrapertools.cache_page(item.url))
    if item.plot == '':
        item.plot= scrapertools.entityunescape(scrapertools.get_match(data,'<p class="sinopsis">(.*?)</p>'))
        print item.plot
    data= scrapertools.get_match(data,patron)
    patron = '<li data-id="(.*?)</li>'
    matches = re.compile(patron,re.DOTALL).findall(data)
    
    '''
    <li data-id="53885">
        <div class="column"><strong>Allmyvideos</strong></div>
        <div class="column" style="width:15%">
            <img src="/images/flags/lang/flag_0.png"/>
        </div> 
        <div class="column">BrScreener/Line</div>
        <div class="column">bibiamorant</div>
        <div class="column" style="width:25%">
            <div class="btn s">
                <a href="/external?action=movie&id=53885" class="" target="_blank">Ver online</a>
            </div> 
            <div class="actions">
                <i id="report-contribution" data-id="53885" class="iconx16 icon3"></i> 
            </div>
        </div>
    </li>
    '''
    
    for i in matches:  
        servidor = scrapertools.get_match(i,'<div class="column"><strong>([^<]+)</strong>') 
        
        mostrar_server= True
        if config.get_setting("hidepremium")=="true":
            mostrar_server= servertools.is_server_enabled (servidor)
        
        if mostrar_server:
            idioma = scrapertools.get_match(i,'<img src="(.*?)"/>')
            if 'flag_0.png' in idioma: 
                idioma ='Es'
            elif 'flag_1.png' in idioma: 
                idioma ='Lat'
            elif 'flag_2.png' in idioma: 
                idioma ='VO'
            elif 'flag_3.png' in idioma: 
                idioma ='VOSE'
            calidad=  scrapertools.get_match(i,'<div class="column">([^<]+)</div>')
            url= __url_base__ + scrapertools.get_match(i,'<a href="([^"]+)"')
            
            title= 'Ver en ' + servidor + ' [' + calidad + '] (' + idioma + ')'
            itemlist.append( Item(channel=__channel__, action="play", viewmode="movie_with_plot", server=servidor, title=title , plot=item.plot, thumbnail=item.thumbnail, fanart= item.fanart, fulltitle = item.title, url=url , extra=item.extra, folder=False) )
            #itemlist.append( Item(channel=__channel__, action="play", server=servidor, title=title , plot=item.plot, thumbnail=item.thumbnail, fanart= item.fanart, fulltitle = item.title, url=url , extra=item.extra, folder=False) )

    
    return itemlist
def findvideos(item):
    logger.info("[newpct1.py] findvideos")
    itemlist=[]   
    

    if "1.com/pelicula" in item.url:
        # Buscamos el fanart en TMDB
        try:
            year=scrapertools.find_single_match(item.show,'(\d{4}$)')
            show = item.show.replace(year,"")
            from core.tmdb import Tmdb
            oTmdb= Tmdb(texto_buscado=show,year=year,tipo="movie")
            item.fanart=oTmdb.get_backdrop()
            item.plot=oTmdb.get_sinopsis()
        except:
            pass
            
    
    ## Cualquiera de las tres opciones son válidas
    #item.url = item.url.replace("1.com/","1.com/ver-online/")
    #item.url = item.url.replace("1.com/","1.com/descarga-directa/")
    item.url = item.url.replace("1.com/","1.com/descarga-torrent/")

    # Descarga la página
    data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)","",scrapertools.cache_page(item.url))
    data = unicode( data, "iso-8859-1" , errors="replace" ).encode("utf-8")
    
    title = scrapertools.find_single_match(data,"<h1><strong>([^<]+)</strong>[^<]+</h1>")
    title+= scrapertools.find_single_match(data,"<h1><strong>[^<]+</strong>([^<]+)</h1>")
    caratula = scrapertools.find_single_match(data,'<div class="entry-left">.*?src="([^"]+)"')

    #<a href="http://tumejorjuego.com/download/index.php?link=descargar-torrent/058310_yo-frankenstein-blurayrip-ac3-51.html" title="Descargar torrent de Yo Frankenstein " class="btn-torrent" target="_blank">Descarga tu Archivo torrent!</a>

    patron = '<a href="([^"]+)" title="[^"]+" class="btn-torrent" target="_blank">'

    # escraped torrent
    url = scrapertools.find_single_match(data,patron)
    if url!="":
        itemlist.append( Item(fanart=item.fanart, channel=__channel__, action="play", server="torrent", title=title+" [torrent]", fulltitle=title, url=url , thumbnail=caratula, plot=item.plot, folder=False) )

    # escraped ver vídeos, descargar vídeos un link, múltiples liks
    data = data.replace("'",'"')
    data = data.replace('javascript:;" onClick="popup("http://www.newpct1.com/pct1/library/include/ajax/get_modallinks.php?links=',"")
    data = data.replace("http://tumejorserie.com/descargar/url_encript.php?link=","")
    data = data.replace("$!","#!")

    patron_descargar = '<div id="tab2"[^>]+>.*?</ul>'
    patron_ver = '<div id="tab3"[^>]+>.*?</ul>'

    match_ver = scrapertools.find_single_match(data,patron_ver)
    match_descargar = scrapertools.find_single_match(data,patron_descargar)

    patron = '<div class="box1"><img src="([^"]+)".*?' # logo
    patron+= '<div class="box2">([^<]+)</div>'         # servidor
    patron+= '<div class="box3">([^<]+)</div>'         # idioma
    patron+= '<div class="box4">([^<]+)</div>'         # calidad
    patron+= '<div class="box5"><a href="([^"]+)".*?'  # enlace
    patron+= '<div class="box6">([^<]+)</div>'         # titulo

    enlaces_ver = re.compile(patron,re.DOTALL).findall(match_ver)
    enlaces_descargar = re.compile(patron,re.DOTALL).findall(match_descargar)

    for logo, servidor, idioma, calidad, enlace, titulo in enlaces_ver:
        servidor = servidor.replace("played","playedto")
        titulo = titulo+" ["+servidor+"]"
        mostrar_server= True
        if config.get_setting("hidepremium")=="true":
            mostrar_server= servertools.is_server_enabled (servidor)
        if mostrar_server:
            try:
                servers_module = __import__("servers."+servidor)
                server_module = getattr(servers_module,servidor)
                devuelve= server_module.find_videos(enlace)
                if devuelve:
                    enlace=devuelve[0][1]
                itemlist.append( Item(fanart=item.fanart, channel=__channel__, action="play", server=servidor, title=titulo , fulltitle = item.title, url=enlace , thumbnail=logo , plot=item.plot, folder=False) )
            except:
                pass
    
    for logo, servidor, idioma, calidad, enlace, titulo in enlaces_descargar:
        servidor = servidor.replace("uploaded","uploadedto")
        partes = enlace.split(" ")
        p = 1
        for enlace in partes:
            parte_titulo = titulo+" (%s/%s)" % (p,len(partes)) + " ["+servidor+"]"
            p+= 1
            mostrar_server= True
            if config.get_setting("hidepremium")=="true":
                mostrar_server= servertools.is_server_enabled (servidor)
            if mostrar_server:
                try:
                    servers_module = __import__("servers."+servidor)
                    server_module = getattr(servers_module,servidor)
                    devuelve= server_module.find_videos(enlace)
                    if devuelve:
                        enlace=devuelve[0][1]
                    itemlist.append( Item(fanart=item.fanart, channel=__channel__, action="play", server=servidor, title=titulo , fulltitle = item.title, url=enlace , thumbnail=logo , plot=item.plot, folder=False) )
                except:
                    pass
    return itemlist
class InfoWindow(xbmcgui.WindowXMLDialog):
    otmdb = None

    item_title = ""
    item_serie = ""
    item_temporada = 0
    item_episodio = 0
    result = {}

    @staticmethod
    def get_language(lng):
        # Cambiamos el formato del Idioma
        languages = {
            'aa': 'Afar', 'ab': 'Abkhazian', 'af': 'Afrikaans', 'ak': 'Akan', 'sq': 'Albanian', 'am': 'Amharic',
            'ar': 'Arabic', 'an': 'Aragonese', 'as': 'Assamese', 'av': 'Avaric', 'ae': 'Avestan',
            'ay': 'Aymara', 'az': 'Azerbaijani', 'ba': 'Bashkir', 'bm': 'Bambara', 'eu': 'Basque',
            'be': 'Belarusian', 'bn': 'Bengali', 'bh': 'Bihari languages', 'bi': 'Bislama',
            'bo': 'Tibetan', 'bs': 'Bosnian', 'br': 'Breton', 'bg': 'Bulgarian', 'my': 'Burmese',
            'ca': 'Catalan; Valencian', 'cs': 'Czech', 'ch': 'Chamorro', 'ce': 'Chechen', 'zh': 'Chinese',
            'cu': 'Church Slavic; Old Slavonic; Church Slavonic; Old Bulgarian; Old Church Slavonic',
            'cv': 'Chuvash', 'kw': 'Cornish', 'co': 'Corsican', 'cr': 'Cree', 'cy': 'Welsh',
            'da': 'Danish', 'de': 'German', 'dv': 'Divehi; Dhivehi; Maldivian', 'nl': 'Dutch; Flemish',
            'dz': 'Dzongkha', 'en': 'English', 'eo': 'Esperanto',
            'et': 'Estonian', 'ee': 'Ewe', 'fo': 'Faroese', 'fa': 'Persian', 'fj': 'Fijian',
            'fi': 'Finnish', 'fr': 'French', 'fy': 'Western Frisian', 'ff': 'Fulah',
            'Ga': 'Georgian', 'gd': 'Gaelic; Scottish Gaelic', 'ga': 'Irish', 'gl': 'Galician',
            'gv': 'Manx', 'el': 'Greek, Modern (1453-)', 'gn': 'Guarani', 'gu': 'Gujarati',
            'ht': 'Haitian; Haitian Creole', 'ha': 'Hausa', 'he': 'Hebrew', 'hz': 'Herero', 'hi': 'Hindi',
            'ho': 'Hiri Motu', 'hr': 'Croatian', 'hu': 'Hungarian', 'hy': 'Armenian', 'ig': 'Igbo',
            'is': 'Icelandic', 'io': 'Ido', 'ii': 'Sichuan Yi; Nuosu', 'iu': 'Inuktitut',
            'ie': 'Interlingue; Occidental', 'ia': 'Interlingua (International Auxiliary Language Association)',
            'id': 'Indonesian', 'ik': 'Inupiaq', 'it': 'Italian', 'jv': 'Javanese',
            'ja': 'Japanese', 'kl': 'Kalaallisut; Greenlandic', 'kn': 'Kannada', 'ks': 'Kashmiri',
            'ka': 'Georgian', 'kr': 'Kanuri', 'kk': 'Kazakh', 'km': 'Central Khmer', 'ki': 'Kikuyu; Gikuyu',
            'rw': 'Kinyarwanda', 'ky': 'Kirghiz; Kyrgyz', 'kv': 'Komi', 'kg': 'Kongo', 'ko': 'Korean',
            'kj': 'Kuanyama; Kwanyama', 'ku': 'Kurdish', 'lo': 'Lao', 'la': 'Latin', 'lv': 'Latvian',
            'li': 'Limburgan; Limburger; Limburgish', 'ln': 'Lingala', 'lt': 'Lithuanian',
            'lb': 'Luxembourgish; Letzeburgesch', 'lu': 'Luba-Katanga', 'lg': 'Ganda', 'mk': 'Macedonian',
            'mh': 'Marshallese', 'ml': 'Malayalam', 'mi': 'Maori', 'mr': 'Marathi', 'ms': 'Malay', 'Mi': 'Micmac',
            'mg': 'Malagasy', 'mt': 'Maltese', 'mn': 'Mongolian', 'na': 'Nauru',
            'nv': 'Navajo; Navaho', 'nr': 'Ndebele, South; South Ndebele', 'nd': 'Ndebele, North; North Ndebele',
            'ng': 'Ndonga', 'ne': 'Nepali', 'nn': 'Norwegian Nynorsk; Nynorsk, Norwegian',
            'nb': 'Bokmål, Norwegian; Norwegian Bokmål', 'no': 'Norwegian', 'oc': 'Occitan (post 1500)',
            'oj': 'Ojibwa', 'or': 'Oriya', 'om': 'Oromo', 'os': 'Ossetian; Ossetic', 'pa': 'Panjabi; Punjabi',
            'pi': 'Pali', 'pl': 'Polish', 'pt': 'Portuguese', 'ps': 'Pushto; Pashto', 'qu': 'Quechua',
            'ro': 'Romanian; Moldavian; Moldovan', 'rn': 'Rundi', 'ru': 'Russian', 'sg': 'Sango', 'rm': 'Romansh',
            'sa': 'Sanskrit', 'si': 'Sinhala; Sinhalese', 'sk': 'Slovak', 'sl': 'Slovenian', 'se': 'Northern Sami',
            'sm': 'Samoan', 'sn': 'Shona', 'sd': 'Sindhi', 'so': 'Somali', 'st': 'Sotho, Southern', 'es': 'Spanish',
            'sc': 'Sardinian', 'sr': 'Serbian', 'ss': 'Swati', 'su': 'Sundanese', 'sw': 'Swahili', 'sv': 'Swedish',
            'ty': 'Tahitian', 'ta': 'Tamil', 'tt': 'Tatar', 'te': 'Telugu', 'tg': 'Tajik', 'tl': 'Tagalog',
            'th': 'Thai', 'ti': 'Tigrinya', 'to': 'Tonga (Tonga Islands)', 'tn': 'Tswana', 'ts': 'Tsonga',
            'tk': 'Turkmen', 'tr': 'Turkish', 'tw': 'Twi', 'ug': 'Uighur; Uyghur', 'uk': 'Ukrainian',
            'ur': 'Urdu', 'uz': 'Uzbek', 've': 'Venda', 'vi': 'Vietnamese', 'vo': 'Volapük',
            'wa': 'Walloon', 'wo': 'Wolof', 'xh': 'Xhosa', 'yi': 'Yiddish', 'yo': 'Yoruba', 'za': 'Zhuang; Chuang',
            'zu': 'Zulu'}

        return languages.get(lng, lng)

    @staticmethod
    def get_date(date):
        # Cambiamos el formato de la fecha
        if date:
            return date.split("-")[2] + "/" + date.split("-")[1] + "/" + date.split("-")[0]
        else:
            return "N/A"

    def get_episode_from_title(self, item):
        # Patron para temporada y episodio "1x01"
        pattern = re.compile("([0-9]+)[ ]*[x|X][ ]*([0-9]+)")

        # Busca en title
        matches = pattern.findall(item.title)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en fulltitle
        matches = pattern.findall(item.fulltitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en contentTitle
        matches = pattern.findall(item.contentTitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

    def get_item_info(self, item):
        # Recogemos los parametros del Item que nos interesan:
        if "title" in item and item.title != "":
            self.item_title = item.title
        if "fulltitle" in item and item.fulltitle != "":
            self.item_title = item.fulltitle
        if "contentTitle" in item and item.contentTitle != "":
            self.item_title = item.contentTitle

        if "show" in item and item.show != "":
            self.item_serie = item.show
        if "contentSerieName" in item and item.contentSerieName != "":
            self.item_serie = item.contentSerieName

        if "contentSeason" in item and item.contentSeason != "":
            self.item_temporada = item.contentSeason
        if "contentepisodeNumber" in item and item.contentepisodeNumber != "":
            self.item_episodio = item.contentepisodeNumber

        # i no existen contentepisodeNumber o contentSeason intenta sacarlo del titulo
        if not self.item_episodio or not self.item_temporada:
            self.get_episode_from_title(item)

    def get_dict_info(self, dct):
        self.result = dct

    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
        self.result["type"] = "movie"
        self.result["id_Tmdb"] = self.otmdb.get_id()
        self.result["title"] = self.otmdb.result["title"]
        self.result["original_title"] = self.otmdb.result["original_title"]
        self.result["date"] = self.get_date(self.otmdb.result["release_date"])
        self.result["language"] = self.get_language(self.otmdb.result["original_language"])
        self.result["rating"] = self.otmdb.result["vote_average"] + "/10 (" + self.otmdb.result["vote_count"] + ")"
        self.result["genres"] = ", ".join(self.otmdb.result["genres"])
        self.result["thumbnail"] = self.otmdb.get_poster()
        self.result["fanart"] = self.otmdb.get_backdrop()
        self.result["overview"] = self.otmdb.result["overview"]

        return True

    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_data(self, data_in):
        self.otmdb = None

        if self.listData:
            data = {}

            if data_in["type"] == "movie":
                # Modo Listado de peliculas
                data["title"] = data_in["title"]
                data["original_title"] = data_in["original_title"]
                data["date"] = self.get_date(data_in["release_date"])

            else:
                # Modo Listado de series
                data["title"] = data_in.get("name", "N/A")

            # Datos comunes a todos los listados
            data["type"] = data_in["type"]
            data["id_Tmdb"] = data_in["id"]
            data["language"] = self.get_language(data_in["original_language"])
            data["rating"] = data_in["vote_average"] + "/10 (" + data_in["vote_count"] + ")"
            data["genres"] = ", ".join(data_in["genres"])
            data["thumbnail"] = data_in["thumbnail"]
            data["fanart"] = data_in["fanart"]
            data["overview"] = data_in.get("overview")
            self.from_tmdb = False
            self.result = data

        else:
            if type(data_in) == Item:
                self.from_tmdb = True
                self.get_item_info(data_in)

                # Modo Pelicula
                if not self.item_serie:
                    encontrado = self.get_tmdb_movie_data(self.item_title)
                    if not encontrado:
                        encontrado = self.get_tmdb_tv_data(self.item_title, self.item_temporada, self.item_episodio)

                else:
                    encontrado = self.get_tmdb_tv_data(self.item_serie, self.item_temporada, self.item_episodio)
                    if not encontrado:
                        encontrado = self.get_tmdb_movie_data(self.item_serie)

            if type(data_in) == dict:
                self.from_tmdb = False
                self.get_dict_info(data_in)

    def Start(self, data, caption="Información del vídeo", callback=None):
        # Capturamos los parametros
        self.caption = caption
        self.callback = callback
        self.indexList = -1
        self.listData = None

        # Obtenemos el canal desde donde se ha echo la llamada y cargamos los settings disponibles para ese canal
        channelpath = inspect.currentframe().f_back.f_back.f_code.co_filename
        self.channel = os.path.basename(channelpath).replace(".py", "")

        if type(data) == list:
            self.listData = data
            self.indexList = 0
            data = self.listData[self.indexList]

        self.get_tmdb_data(data)

        # Muestra la ventana
        self.return_value = None
        self.doModal()
        return self.return_value

    def onInit(self):
        # Ponemos el foco en el boton de cerrar [X]
        self.setFocus(self.getControl(10003))

        # Ponemos el título y las imagenes
        self.getControl(10002).setLabel(self.caption)
        self.getControl(10004).setImage(self.result.get("fanart", ""))
        self.getControl(10005).setImage(self.result.get("thumbnail", "InfoWindow/img_no_disponible.png"))

        # Cargamos los datos para el formato pelicula
        if self.result.get("type", "movie") == "movie":
            self.getControl(10006).setLabel("Titulo:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Titulo Original:")
            self.getControl(10009).setLabel(self.result.get("original_title", "N/A"))
            self.getControl(100010).setLabel("Idioma original:")
            self.getControl(100011).setLabel(self.result.get("language", "N/A"))
            self.getControl(100012).setLabel("Puntuacion:")
            self.getControl(100013).setLabel(self.result.get("rating", "N/A"))
            self.getControl(100014).setLabel("Lanzamiento:")
            self.getControl(100015).setLabel(self.result.get("date", "N/A"))
            self.getControl(100016).setLabel("Generos:")
            self.getControl(100017).setLabel(self.result.get("genres", "N/A"))

        # Cargamos los datos para el formato serie
        else:
            self.getControl(10006).setLabel("Serie:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Idioma original:")
            self.getControl(10009).setLabel(self.result.get("language", "N/A"))
            self.getControl(100010).setLabel("Puntuacion:")
            self.getControl(100011).setLabel(self.result.get("rating", "N/A"))
            self.getControl(100012).setLabel("Generos:")
            self.getControl(100013).setLabel(self.result.get("genres", "N/A"))
            if self.result.get("season") and self.result.get("episode"):
                self.getControl(100014).setLabel("Titulo:")
                self.getControl(100015).setLabel(self.result.get("episode_title", "N/A"))
                self.getControl(100016).setLabel("Temporada:")
                self.getControl(100017).setLabel(self.result.get("season", "N/A") + " de " +
                                                 self.result.get("seasons", "N/A"))
                self.getControl(100018).setLabel("Episodio:")
                self.getControl(100019).setLabel(self.result.get("episode", "N/A") + " de " +
                                                 self.result.get("episodes", "N/A"))
                self.getControl(100020).setLabel("Emision:")
                self.getControl(100021).setLabel(self.result.get("date", "N/A"))

        # Sinopsis
        if "overview" in self.result and self.result['overview']:
            self.getControl(100022).setLabel("Sinopsis:")
            self.getControl(100023).setText(self.result.get("overview", "N/A"))
        else:
            self.getControl(100022).setLabel("")
            self.getControl(100023).setText("")

        # Cargamos los botones si es necesario
        self.getControl(10024).setVisible(self.indexList > -1)
        self.getControl(10025).setEnabled(self.indexList > 0)
        self.getControl(10026).setEnabled(self.indexList + 1 != len(self.listData))
        self.getControl(100029).setLabel("({0}/{1})".format(self.indexList + 1, len(self.listData)))

        # Ponemos el foto en el botón "Anterior",
        # si estuviera desactivado iria el foco al boton "Siguiente" y pasara lo mismo al botón "Cancelar"
        self.setFocus(self.getControl(10024))

    def onClick(self, id):
        logger.info("pelisalacarta.platformcode.xbmc_info_window onClick id="+repr(id))
        # Boton Cancelar y [X]
        if id == 10003 or id == 10027:
            self.close()

        # Boton Anterior
        if id == 10025 and self.indexList > 0:
            self.indexList -= 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Siguiente
        if id == 10026 and self.indexList < len(self.listData) - 1:
            self.indexList += 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Aceptar, Cancelar y [X]
        if id == 10028 or id == 10003 or id == 10027:
            self.close()

            if self.callback:
                cb_channel = None
                try:
                    cb_channel = __import__('platformcode.%s' % self.channel,
                                            fromlist=["platformcode.%s" % self.channel])
                except ImportError:
                    logger.error('Imposible importar %s' % self.channel)

                if id == 10028:  # Boton Aceptar
                    if cb_channel:
                        self.return_value = getattr(cb_channel, self.callback)(self.result)
                else:  # Boton Cancelar y [X]
                    if cb_channel:
                        self.return_value = getattr(cb_channel, self.callback)(None)

    def onAction(self, action):
        # logger.info("pelisalacarta.platformcode.xbmc_info_window onAction action="+repr(action.getId()))

        # Accion 1: Flecha izquierda
        if action == 1:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Aceptar
            if focus == 10028:
                self.setFocus(self.getControl(10027))
            # botón Cancelar
            elif focus == 10027:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                elif self.indexList > 0:
                    # vamos al botón Anterior ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10025))
            # botón Siguiente
            elif focus == 10026:
                if self.indexList > 0:
                    # vamos al botón Anterior
                    self.setFocus(self.getControl(10025))

        # Accion 2: Flecha derecha
        if action == 2:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Anterior
            if focus == 10025:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                else:
                    # vamos al botón Cancelar ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10027))
            # botón Siguiente
            elif focus == 10026:
                self.setFocus(self.getControl(10027))
            # boton Cancelar
            elif focus == 10027:
                self.setFocus(self.getControl(10028))

        # Pulsa OK, simula click en boton aceptar
        # if action == 107: # es mover el ratón
        #     logger.info("onAction he pulstado ok")
        #     # self.onClick(10028)

        # Pulsa ESC o Atrás, simula click en boton cancelar
        if action in [10, 92]:
            # TODO arreglar
            # self.close()
            self.onClick(10027)
Exemple #42
0
def completo(item):
    logger.info("[newpct1.py] completo")
    itemlist = []
    categoryID=""
    
    # Guarda el valor por si son etiquetas para que lo vea 'listadofichas'
    item_extra = item.extra
    item_show= item.show
    item_title= item.title
       
    # Lee las entradas
    if item_extra.startswith("serie"):
        ultimo_action="get_episodios"
        
        if item.extra !="serie_add":
            '''
            # Afinar mas la busqueda 
            if item_extra=="serie-hd":
                categoryID=buscar_en_subcategoria(item.show,'1469')
            elif item_extra=="serie-vo":
                categoryID=buscar_en_subcategoria(item.show,'775')
            elif item_extra=="serie-tv":
                categoryID=buscar_en_subcategoria(item.show,'767')
            if categoryID !="":
                item.url=item.url.replace("categoryID=","categoryID="+categoryID)
                
            #Fanart
            oTvdb= TvDb()
            serieID=oTvdb.get_serieId_by_title(item.show)
            fanart = oTvdb.get_graphics_by_serieId(serieID)
            if len(fanart)>0:
                item.fanart = fanart[0]'''
            try:
                from core.tmdb import Tmdb
                oTmdb= Tmdb(texto_buscado=item.show,tipo="tv",idioma_busqueda="es")
                item.fanart=oTmdb.get_backdrop()
                item.plot=oTmdb.get_sinopsis()
                print item.plot
            except:
                pass
        else:
            item_title= item.show
        
        items_programas = get_episodios(item)        
    else:
        ultimo_action="listado"
        items_programas = listado(item)
        
    if len(items_programas) ==0:
            return itemlist # devolver lista vacia
            
    salir = False
    while not salir:

        # Saca la URL de la siguiente página    
        ultimo_item = items_programas[ len(items_programas)-1 ]
       
        # Páginas intermedias
        if ultimo_item.action==ultimo_action:
            # Quita el elemento de "Página siguiente" 
            ultimo_item = items_programas.pop()

            # Añade las entradas de la página a la lista completa
            itemlist.extend( items_programas )
    
            # Carga la siguiente página
            ultimo_item.extra = item_extra
            ultimo_item.show = item_show
            ultimo_item.title = item_title
            logger.info("[newpct1.py] completo url=" + ultimo_item.url)
            if item_extra.startswith("serie"):
                items_programas = get_episodios(ultimo_item)
            else:
                items_programas = listado(ultimo_item)
                
        # Última página
        else:
            # Añade a la lista completa y sale
            itemlist.extend( items_programas )
            salir = True          
      
    if (config.get_library_support() and len(itemlist)>0 and item.extra.startswith("serie")) :
        itemlist.append( Item(channel=item.channel, title="Añadir esta serie a la biblioteca", url=item.url, action="add_serie_to_library", extra="completo###serie_add" , show= item.show))
    logger.info("[newpct1.py] completo items="+ str(len(itemlist)))
    return itemlist
Exemple #43
0
def search_trailers(item):
    logger.info()

    from core.tmdb import Tmdb
    import xbmcgui, xbmc

    tipo = 'movie' if item.contentType == 'movie' else 'tv'
    nombre = item.contentTitle if item.contentType == 'movie' else item.contentSerieName
    if item.infoLabels['tmdb_id']:
        tmdb_search = Tmdb(id_Tmdb=item.infoLabels['tmdb_id'],
                           tipo=tipo,
                           idioma_busqueda='es')
    else:
        anyo = item.infoLabels['year'] if item.infoLabels['year'] else '-'
        tmdb_search = Tmdb(texto_buscado=nombre,
                           tipo=tipo,
                           year=anyo,
                           idioma_busqueda='es')

    opciones = []
    resultados = tmdb_search.get_videos()
    for res in resultados:
        # ~ logger.debug(res)
        it = xbmcgui.ListItem(res['name'],
                              '[%sp] (%s)' % (res['size'], res['language']))
        if item.thumbnail: it.setArt({'thumb': item.thumbnail})
        opciones.append(it)

    if len(resultados) == 0:
        platformtools.dialog_ok(nombre,
                                'No se encuentra ningún tráiler en TMDB')
    else:
        while not xbmc.Monitor().abortRequested():  # (while True)
            ret = xbmcgui.Dialog().select('Tráilers para %s' % nombre,
                                          opciones,
                                          useDetails=True)
            if ret == -1: break

            platformtools.dialog_notification(resultados[ret]['name'],
                                              'Cargando tráiler ...',
                                              time=3000,
                                              sound=False)
            from core import servertools
            if 'youtube' in resultados[ret]['url']:
                video_urls, puedes, motivo = servertools.resolve_video_urls_for_playing(
                    'youtube', resultados[ret]['url'])
            else:
                video_urls = []  #TODO si no es youtube ...
                logger.debug(resultados[ret])
            if len(video_urls) > 0:
                # ~ logger.debug(video_urls)
                xbmc.Player().play(
                    video_urls[-1][1])  # el último es el de más calidad
                xbmc.sleep(1000)
                while not xbmc.Monitor().abortRequested() and xbmc.Player(
                ).isPlaying():
                    xbmc.sleep(1000)
            else:
                platformtools.dialog_notification(
                    resultados[ret]['name'],
                    'No se puede reproducir el tráiler',
                    time=3000,
                    sound=False)

            if len(resultados) == 1:
                break  # si sólo hay un vídeo no volver al diálogo de tráilers
Exemple #44
0
def findvideostv(item):
    logger.info("pelisalacarta.channels.allpeliculas findvideostv")
    itemlist = []
    season = item.title.split(" ")[1]
    thumbnail = item.thumbnail
    #Rellena diccionarios idioma y calidad
    idiomas_videos, calidad_videos = dict_videos()

    data = scrapertools.cachePage(item.url)
    data = data.replace("\n", "").replace("\t", "")
    data = scrapertools.decodeHtmlentities(data)
    try:
        from core.tmdb import Tmdb
        otmdb = Tmdb(texto_buscado=item.fulltitle, tipo="tv")
    except:
        pass
    #Enlaces Online
    patron = '<span class="movie-online-list" id_movies_types="([^"]+)".*?episode="([^"]+)" season="' + season + '" id_lang="([^"]+)".*?online-link="([^"]+)"'
    matches = scrapertools.find_multiple_matches(data, patron)
    for quality, episode, language, url in matches:
        enlaces = servertools.findvideos(data=url)
        if len(enlaces) > 0:
            idioma = IDIOMAS.get(idiomas_videos.get(language))
            titulo = "[COLOR sandybrown][B]Episodio " + episode + "[/B][/COLOR] "
            titulo += "Enlace encontrado en [COLOR green][B]" + enlaces[0][
                0] + "[/B][/COLOR] [COLOR magenta][" + idioma + "][/COLOR] [" + calidad_videos.get(
                    quality) + "]"
            servidor = enlaces[0][2]
            try:
                item.plot, thumbnail = infoepi(otmdb, season, episode)
            except:
                pass
            itemlist.append(
                Item(channel=__channel__,
                     action="play",
                     server=servidor,
                     title=titulo,
                     url=enlaces[0][1],
                     fulltitle=item.fulltitle,
                     thumbnail=thumbnail,
                     fanart=item.fanart,
                     plot=str(item.plot),
                     extra=episode,
                     folder=False))

    #Enlace Descarga
    patron = '<span class="movie-downloadlink-list" id_movies_types="([^"]+)".*?episode="([^"]+)" season="' + season + '" id_lang="([^"]+)".*?online-link="([^"]+)"'
    matches = scrapertools.find_multiple_matches(data, patron)
    for quality, episode, language, url in matches:
        mostrar_server = True
        enlaces = servertools.findvideos(data=url)
        if len(enlaces) > 0:
            servidor = enlaces[0][2]
            if config.get_setting("hidepremium") == "true":
                mostrar_server = servertools.is_server_enabled(servidor)
            if mostrar_server:
                idioma = IDIOMAS.get(idiomas_videos.get(language))
                titulo = "[COLOR sandybrown][B]Episodio " + episode + "[/B][/COLOR] "
                titulo += "Enlace encontrado en [COLOR green][B]" + enlaces[0][
                    0] + "[/B][/COLOR] [" + idioma + "] [" + calidad_videos.get(
                        quality) + "]"
                try:
                    item.plot, thumbnail = infoepi(otmdb, season, episode)
                except:
                    pass
                itemlist.append(
                    Item(channel=__channel__,
                         action="play",
                         server=servidor,
                         title=titulo,
                         url=enlaces[0][1],
                         fulltitle=item.fulltitle,
                         thumbnail=thumbnail,
                         fanart=item.fanart,
                         plot=str(item.plot),
                         extra=episode,
                         folder=False))

    itemlist.sort(key=lambda item: (int(item.extra), item.title))
    return itemlist
Exemple #45
0
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)
class InfoWindow(xbmcgui.WindowXMLDialog):
    otmdb = None

    item_title = ""
    item_serie = ""
    item_temporada = 0
    item_episodio = 0
    result = {}

    @staticmethod
    def get_language(lng):
        # Cambiamos el formato del Idioma
        languages = {
            "aa": "Afar",
            "ab": "Abkhazian",
            "af": "Afrikaans",
            "ak": "Akan",
            "sq": "Albanian",
            "am": "Amharic",
            "ar": "Arabic",
            "an": "Aragonese",
            "as": "Assamese",
            "av": "Avaric",
            "ae": "Avestan",
            "ay": "Aymara",
            "az": "Azerbaijani",
            "ba": "Bashkir",
            "bm": "Bambara",
            "eu": "Basque",
            "be": "Belarusian",
            "bn": "Bengali",
            "bh": "Bihari languages",
            "bi": "Bislama",
            "bo": "Tibetan",
            "bs": "Bosnian",
            "br": "Breton",
            "bg": "Bulgarian",
            "my": "Burmese",
            "ca": "Catalan; Valencian",
            "cs": "Czech",
            "ch": "Chamorro",
            "ce": "Chechen",
            "zh": "Chinese",
            "cu": "Church Slavic; Old Slavonic; Church Slavonic; Old Bulgarian; Old Church Slavonic",
            "cv": "Chuvash",
            "kw": "Cornish",
            "co": "Corsican",
            "cr": "Cree",
            "cy": "Welsh",
            "da": "Danish",
            "de": "German",
            "dv": "Divehi; Dhivehi; Maldivian",
            "nl": "Dutch; Flemish",
            "dz": "Dzongkha",
            "en": "English",
            "eo": "Esperanto",
            "et": "Estonian",
            "ee": "Ewe",
            "fo": "Faroese",
            "fa": "Persian",
            "fj": "Fijian",
            "fi": "Finnish",
            "fr": "French",
            "fy": "Western Frisian",
            "ff": "Fulah",
            "Ga": "Georgian",
            "gd": "Gaelic; Scottish Gaelic",
            "ga": "Irish",
            "gl": "Galician",
            "gv": "Manx",
            "el": "Greek, Modern (1453-)",
            "gn": "Guarani",
            "gu": "Gujarati",
            "ht": "Haitian; Haitian Creole",
            "ha": "Hausa",
            "he": "Hebrew",
            "hz": "Herero",
            "hi": "Hindi",
            "ho": "Hiri Motu",
            "hr": "Croatian",
            "hu": "Hungarian",
            "hy": "Armenian",
            "ig": "Igbo",
            "is": "Icelandic",
            "io": "Ido",
            "ii": "Sichuan Yi; Nuosu",
            "iu": "Inuktitut",
            "ie": "Interlingue; Occidental",
            "ia": "Interlingua (International Auxiliary Language Association)",
            "id": "Indonesian",
            "ik": "Inupiaq",
            "it": "Italian",
            "jv": "Javanese",
            "ja": "Japanese",
            "kl": "Kalaallisut; Greenlandic",
            "kn": "Kannada",
            "ks": "Kashmiri",
            "ka": "Georgian",
            "kr": "Kanuri",
            "kk": "Kazakh",
            "km": "Central Khmer",
            "ki": "Kikuyu; Gikuyu",
            "rw": "Kinyarwanda",
            "ky": "Kirghiz; Kyrgyz",
            "kv": "Komi",
            "kg": "Kongo",
            "ko": "Korean",
            "kj": "Kuanyama; Kwanyama",
            "ku": "Kurdish",
            "lo": "Lao",
            "la": "Latin",
            "lv": "Latvian",
            "li": "Limburgan; Limburger; Limburgish",
            "ln": "Lingala",
            "lt": "Lithuanian",
            "lb": "Luxembourgish; Letzeburgesch",
            "lu": "Luba-Katanga",
            "lg": "Ganda",
            "mk": "Macedonian",
            "mh": "Marshallese",
            "ml": "Malayalam",
            "mi": "Maori",
            "mr": "Marathi",
            "ms": "Malay",
            "Mi": "Micmac",
            "mg": "Malagasy",
            "mt": "Maltese",
            "mn": "Mongolian",
            "na": "Nauru",
            "nv": "Navajo; Navaho",
            "nr": "Ndebele, South; South Ndebele",
            "nd": "Ndebele, North; North Ndebele",
            "ng": "Ndonga",
            "ne": "Nepali",
            "nn": "Norwegian Nynorsk; Nynorsk, Norwegian",
            "nb": "Bokmål, Norwegian; Norwegian Bokmål",
            "no": "Norwegian",
            "oc": "Occitan (post 1500)",
            "oj": "Ojibwa",
            "or": "Oriya",
            "om": "Oromo",
            "os": "Ossetian; Ossetic",
            "pa": "Panjabi; Punjabi",
            "pi": "Pali",
            "pl": "Polish",
            "pt": "Portuguese",
            "ps": "Pushto; Pashto",
            "qu": "Quechua",
            "ro": "Romanian; Moldavian; Moldovan",
            "rn": "Rundi",
            "ru": "Russian",
            "sg": "Sango",
            "rm": "Romansh",
            "sa": "Sanskrit",
            "si": "Sinhala; Sinhalese",
            "sk": "Slovak",
            "sl": "Slovenian",
            "se": "Northern Sami",
            "sm": "Samoan",
            "sn": "Shona",
            "sd": "Sindhi",
            "so": "Somali",
            "st": "Sotho, Southern",
            "es": "Spanish",
            "sc": "Sardinian",
            "sr": "Serbian",
            "ss": "Swati",
            "su": "Sundanese",
            "sw": "Swahili",
            "sv": "Swedish",
            "ty": "Tahitian",
            "ta": "Tamil",
            "tt": "Tatar",
            "te": "Telugu",
            "tg": "Tajik",
            "tl": "Tagalog",
            "th": "Thai",
            "ti": "Tigrinya",
            "to": "Tonga (Tonga Islands)",
            "tn": "Tswana",
            "ts": "Tsonga",
            "tk": "Turkmen",
            "tr": "Turkish",
            "tw": "Twi",
            "ug": "Uighur; Uyghur",
            "uk": "Ukrainian",
            "ur": "Urdu",
            "uz": "Uzbek",
            "ve": "Venda",
            "vi": "Vietnamese",
            "vo": "Volapük",
            "wa": "Walloon",
            "wo": "Wolof",
            "xh": "Xhosa",
            "yi": "Yiddish",
            "yo": "Yoruba",
            "za": "Zhuang; Chuang",
            "zu": "Zulu",
        }

        return languages.get(lng, lng)

    @staticmethod
    def get_date(date):
        # Cambiamos el formato de la fecha
        if date:
            return date.split("-")[2] + "/" + date.split("-")[1] + "/" + date.split("-")[0]
        else:
            return "N/A"

    def get_episode_from_title(self, item):
        # Patron para temporada y episodio "1x01"
        pattern = re.compile("([0-9]+)[ ]*[x|X][ ]*([0-9]+)")

        # Busca en title
        matches = pattern.findall(item.title)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en fulltitle
        matches = pattern.findall(item.fulltitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en contentTitle
        matches = pattern.findall(item.contentTitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

    def get_item_info(self, item):
        # Recogemos los parametros del Item que nos interesan:
        self.item_title = item.title
        if item.fulltitle:
            self.item_title = item.fulltitle
        if item.contentTitle:
            self.item_title = item.contentTitle

        if item.show:
            self.item_serie = item.show
        if item.contentSerieName:
            self.item_serie = item.contentSerieName

        if item.contentSeason:
            self.item_temporada = item.contentSeason
        if item.contentEpisodeNumber:
            self.item_episodio = item.contentEpisodeNumber

        # i no existen contentepisodeNumber o contentSeason intenta sacarlo del titulo
        if not self.item_episodio or not self.item_temporada:
            self.get_episode_from_title(item)

    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

    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 get_tmdb_data(self, data_in):
        self.otmdb = None
        # logger.debug(str(data_in))

        if self.listData:
            infoLabels = InfoLabels()

            # Datos comunes a todos los listados
            infoLabels = Tmdb().get_infoLabels(infoLabels=infoLabels, origen=data_in)
            infoLabels["language"] = self.get_language(infoLabels["original_language"])
            infoLabels["puntuacion"] = str(data_in["vote_average"]) + "/10 (" + str(data_in["vote_count"]) + ")"

            self.from_tmdb = False
            self.result = infoLabels

        else:
            if isinstance(data_in, Item):
                self.from_tmdb = True
                self.get_item_info(data_in)

                # Modo Pelicula
                if not self.item_serie:
                    encontrado = self.get_tmdb_movie_data(self.item_title)
                    if not encontrado:
                        encontrado = self.get_tmdb_tv_data(self.item_title)

                else:
                    encontrado = self.get_tmdb_tv_data(self.item_serie)
                    if not encontrado:
                        encontrado = self.get_tmdb_movie_data(self.item_serie)

            if isinstance(data_in, dict):
                self.from_tmdb = False
                self.result = InfoLabels(data_in)

        # logger.debug(str(self.result))

    def Start(self, data, caption="Información del vídeo", callback=None, item=None):
        # Capturamos los parametros
        self.caption = caption
        self.callback = callback
        self.item = item
        self.indexList = -1
        self.listData = None
        self.return_value = None

        # Obtenemos el canal desde donde se ha echo la llamada y cargamos los settings disponibles para ese canal
        channelpath = inspect.currentframe().f_back.f_back.f_code.co_filename
        self.channel = os.path.basename(channelpath).replace(".py", "")

        if type(data) == list:
            self.listData = data
            self.indexList = 0
            data = self.listData[self.indexList]

        self.get_tmdb_data(data)

        # Muestra la ventana
        self.doModal()
        return self.return_value

    def onInit(self):
        # Ponemos el foco en el boton de cerrar [X]
        self.setFocus(self.getControl(10003))

        # Ponemos el título y las imagenes
        self.getControl(10002).setLabel(self.caption)
        self.getControl(10004).setImage(self.result.get("fanart", ""))
        self.getControl(10005).setImage(self.result.get("thumbnail", "InfoWindow/img_no_disponible.png"))

        # Cargamos los datos para el formato pelicula
        if self.result.get("mediatype", "movie") == "movie":
            self.getControl(10006).setLabel("Titulo:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Titulo Original:")
            self.getControl(10009).setLabel(self.result.get("originaltitle", "N/A"))
            self.getControl(100010).setLabel("Idioma original:")
            self.getControl(100011).setLabel(self.result.get("language", "N/A"))
            self.getControl(100012).setLabel("Puntuacion:")
            self.getControl(100013).setLabel(self.result.get("puntuacion", "N/A"))
            self.getControl(100014).setLabel("Lanzamiento:")
            self.getControl(100015).setLabel(self.result.get("release_date", "N/A"))
            self.getControl(100016).setLabel("Generos:")
            self.getControl(100017).setLabel(self.result.get("genre", "N/A"))

        # Cargamos los datos para el formato serie
        else:
            self.getControl(10006).setLabel("Serie:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Idioma original:")
            self.getControl(10009).setLabel(self.result.get("language", "N/A"))
            self.getControl(100010).setLabel("Puntuacion:")
            self.getControl(100011).setLabel(self.result.get("puntuacion", "N/A"))
            self.getControl(100012).setLabel("Generos:")
            self.getControl(100013).setLabel(self.result.get("genre", "N/A"))

            if self.result.get("season"):
                self.getControl(100014).setLabel("Titulo temporada:")
                self.getControl(100015).setLabel(self.result.get("temporada_nombre", "N/A"))
                self.getControl(100016).setLabel("Temporada:")
                self.getControl(100017).setLabel(
                    self.result.get("season", "N/A") + " de " + self.result.get("seasons", "N/A")
                )
            if self.result.get("episode"):
                self.getControl(100014).setLabel("Titulo:")
                self.getControl(100015).setLabel(self.result.get("episode_title", "N/A"))
                self.getControl(100018).setLabel("Episodio:")
                self.getControl(100019).setLabel(
                    self.result.get("episode", "N/A") + " de " + self.result.get("episodes", "N/A")
                )
                self.getControl(100020).setLabel("Emision:")
                self.getControl(100021).setLabel(self.result.get("date", "N/A"))

        # Sinopsis
        if self.result["plot"]:
            self.getControl(100022).setLabel("Sinopsis:")
            self.getControl(100023).setText(self.result.get("plot", "N/A"))
        else:
            self.getControl(100022).setLabel("")
            self.getControl(100023).setText("")

        # Cargamos los botones si es necesario
        self.getControl(10024).setVisible(self.indexList > -1)  # Grupo de botones
        self.getControl(10025).setEnabled(self.indexList > 0)  # Anterior
        if self.listData:
            m = len(self.listData)
        else:
            m = 1
        self.getControl(10026).setEnabled(self.indexList + 1 != m)  # Siguiente
        self.getControl(100029).setLabel("(%s/%s)" % (self.indexList + 1, m))  # x/m

        # Ponemos el foco en el botón "Anterior",
        # si estuviera desactivado iria el foco al boton "Siguiente" y pasara lo mismo al botón "Cancelar"
        self.setFocus(self.getControl(10024))

    def onClick(self, id):
        logger.info("pelisalacarta.platformcode.xbmc_info_window onClick id=" + repr(id))
        # Boton Cancelar y [X]
        if id == 10003 or id == 10027:
            self.close()

        # Boton Anterior
        if id == 10025 and self.indexList > 0:
            self.indexList -= 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Siguiente
        if id == 10026 and self.indexList < len(self.listData) - 1:
            self.indexList += 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Aceptar, Cancelar y [X]
        if id == 10028 or id == 10003 or id == 10027:
            self.close()

            if self.callback:
                cb_channel = None
                try:
                    cb_channel = __import__("core.%s" % self.channel, fromlist=["core.%s" % self.channel])
                except ImportError:
                    logger.error("Imposible importar %s" % self.channel)

                if id == 10028:  # Boton Aceptar
                    if cb_channel:
                        self.return_value = getattr(cb_channel, self.callback)(self.item, self.listData[self.indexList])
                else:  # Boton Cancelar y [X]
                    if cb_channel:
                        self.return_value = getattr(cb_channel, self.callback)(self.item, None)

    def onAction(self, action):
        logger.info("pelisalacarta.platformcode.xbmc_info_window onAction action=" + repr(action.getId()))

        # Accion 1: Flecha izquierda
        if action == 1:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Aceptar
            if focus == 10028:
                self.setFocus(self.getControl(10027))
            # botón Cancelar
            elif focus == 10027:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                elif self.indexList > 0:
                    # vamos al botón Anterior ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10025))
            # botón Siguiente
            elif focus == 10026:
                if self.indexList > 0:
                    # vamos al botón Anterior
                    self.setFocus(self.getControl(10025))

        # Accion 2: Flecha derecha
        if action == 2:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Anterior
            if focus == 10025:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                else:
                    # vamos al botón Cancelar ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10027))
            # botón Siguiente
            elif focus == 10026:
                self.setFocus(self.getControl(10027))
            # boton Cancelar
            elif focus == 10027:
                self.setFocus(self.getControl(10028))

        # Pulsa OK, simula click en boton aceptar
        # if action == 107: # es mover el ratón
        #     logger.info("onAction he pulstado ok")
        #     # self.onClick(10028)

        # Pulsa ESC o Atrás, simula click en boton cancelar
        if action in [10, 92]:
            # TODO arreglar
            # self.close()
            self.onClick(10027)
class InfoWindow(xbmcgui.WindowXMLDialog):
    otmdb = None

    item_title = ""
    item_serie = ""
    item_temporada = 0
    item_episodio = 0
    result = {}

    @staticmethod
    def get_language(lng):
        # Cambiamos el formato del Idioma
        languages = {
            'aa': 'Afar',
            'ab': 'Abkhazian',
            'af': 'Afrikaans',
            'ak': 'Akan',
            'sq': 'Albanian',
            'am': 'Amharic',
            'ar': 'Arabic',
            'an': 'Aragonese',
            'as': 'Assamese',
            'av': 'Avaric',
            'ae': 'Avestan',
            'ay': 'Aymara',
            'az': 'Azerbaijani',
            'ba': 'Bashkir',
            'bm': 'Bambara',
            'eu': 'Basque',
            'be': 'Belarusian',
            'bn': 'Bengali',
            'bh': 'Bihari languages',
            'bi': 'Bislama',
            'bo': 'Tibetan',
            'bs': 'Bosnian',
            'br': 'Breton',
            'bg': 'Bulgarian',
            'my': 'Burmese',
            'ca': 'Catalan; Valencian',
            'cs': 'Czech',
            'ch': 'Chamorro',
            'ce': 'Chechen',
            'zh': 'Chinese',
            'cu':
            'Church Slavic; Old Slavonic; Church Slavonic; Old Bulgarian; Old Church Slavonic',
            'cv': 'Chuvash',
            'kw': 'Cornish',
            'co': 'Corsican',
            'cr': 'Cree',
            'cy': 'Welsh',
            'da': 'Danish',
            'de': 'German',
            'dv': 'Divehi; Dhivehi; Maldivian',
            'nl': 'Dutch; Flemish',
            'dz': 'Dzongkha',
            'en': 'English',
            'eo': 'Esperanto',
            'et': 'Estonian',
            'ee': 'Ewe',
            'fo': 'Faroese',
            'fa': 'Persian',
            'fj': 'Fijian',
            'fi': 'Finnish',
            'fr': 'French',
            'fy': 'Western Frisian',
            'ff': 'Fulah',
            'Ga': 'Georgian',
            'gd': 'Gaelic; Scottish Gaelic',
            'ga': 'Irish',
            'gl': 'Galician',
            'gv': 'Manx',
            'el': 'Greek, Modern (1453-)',
            'gn': 'Guarani',
            'gu': 'Gujarati',
            'ht': 'Haitian; Haitian Creole',
            'ha': 'Hausa',
            'he': 'Hebrew',
            'hz': 'Herero',
            'hi': 'Hindi',
            'ho': 'Hiri Motu',
            'hr': 'Croatian',
            'hu': 'Hungarian',
            'hy': 'Armenian',
            'ig': 'Igbo',
            'is': 'Icelandic',
            'io': 'Ido',
            'ii': 'Sichuan Yi; Nuosu',
            'iu': 'Inuktitut',
            'ie': 'Interlingue; Occidental',
            'ia': 'Interlingua (International Auxiliary Language Association)',
            'id': 'Indonesian',
            'ik': 'Inupiaq',
            'it': 'Italian',
            'jv': 'Javanese',
            'ja': 'Japanese',
            'kl': 'Kalaallisut; Greenlandic',
            'kn': 'Kannada',
            'ks': 'Kashmiri',
            'ka': 'Georgian',
            'kr': 'Kanuri',
            'kk': 'Kazakh',
            'km': 'Central Khmer',
            'ki': 'Kikuyu; Gikuyu',
            'rw': 'Kinyarwanda',
            'ky': 'Kirghiz; Kyrgyz',
            'kv': 'Komi',
            'kg': 'Kongo',
            'ko': 'Korean',
            'kj': 'Kuanyama; Kwanyama',
            'ku': 'Kurdish',
            'lo': 'Lao',
            'la': 'Latin',
            'lv': 'Latvian',
            'li': 'Limburgan; Limburger; Limburgish',
            'ln': 'Lingala',
            'lt': 'Lithuanian',
            'lb': 'Luxembourgish; Letzeburgesch',
            'lu': 'Luba-Katanga',
            'lg': 'Ganda',
            'mk': 'Macedonian',
            'mh': 'Marshallese',
            'ml': 'Malayalam',
            'mi': 'Maori',
            'mr': 'Marathi',
            'ms': 'Malay',
            'Mi': 'Micmac',
            'mg': 'Malagasy',
            'mt': 'Maltese',
            'mn': 'Mongolian',
            'na': 'Nauru',
            'nv': 'Navajo; Navaho',
            'nr': 'Ndebele, South; South Ndebele',
            'nd': 'Ndebele, North; North Ndebele',
            'ng': 'Ndonga',
            'ne': 'Nepali',
            'nn': 'Norwegian Nynorsk; Nynorsk, Norwegian',
            'nb': 'Bokmål, Norwegian; Norwegian Bokmål',
            'no': 'Norwegian',
            'oc': 'Occitan (post 1500)',
            'oj': 'Ojibwa',
            'or': 'Oriya',
            'om': 'Oromo',
            'os': 'Ossetian; Ossetic',
            'pa': 'Panjabi; Punjabi',
            'pi': 'Pali',
            'pl': 'Polish',
            'pt': 'Portuguese',
            'ps': 'Pushto; Pashto',
            'qu': 'Quechua',
            'ro': 'Romanian; Moldavian; Moldovan',
            'rn': 'Rundi',
            'ru': 'Russian',
            'sg': 'Sango',
            'rm': 'Romansh',
            'sa': 'Sanskrit',
            'si': 'Sinhala; Sinhalese',
            'sk': 'Slovak',
            'sl': 'Slovenian',
            'se': 'Northern Sami',
            'sm': 'Samoan',
            'sn': 'Shona',
            'sd': 'Sindhi',
            'so': 'Somali',
            'st': 'Sotho, Southern',
            'es': 'Spanish',
            'sc': 'Sardinian',
            'sr': 'Serbian',
            'ss': 'Swati',
            'su': 'Sundanese',
            'sw': 'Swahili',
            'sv': 'Swedish',
            'ty': 'Tahitian',
            'ta': 'Tamil',
            'tt': 'Tatar',
            'te': 'Telugu',
            'tg': 'Tajik',
            'tl': 'Tagalog',
            'th': 'Thai',
            'ti': 'Tigrinya',
            'to': 'Tonga (Tonga Islands)',
            'tn': 'Tswana',
            'ts': 'Tsonga',
            'tk': 'Turkmen',
            'tr': 'Turkish',
            'tw': 'Twi',
            'ug': 'Uighur; Uyghur',
            'uk': 'Ukrainian',
            'ur': 'Urdu',
            'uz': 'Uzbek',
            've': 'Venda',
            'vi': 'Vietnamese',
            'vo': 'Volapük',
            'wa': 'Walloon',
            'wo': 'Wolof',
            'xh': 'Xhosa',
            'yi': 'Yiddish',
            'yo': 'Yoruba',
            'za': 'Zhuang; Chuang',
            'zu': 'Zulu'
        }

        return languages.get(lng, lng)

    @staticmethod
    def get_date(date):
        # Cambiamos el formato de la fecha
        if date:
            return date.split("-")[2] + "/" + date.split(
                "-")[1] + "/" + date.split("-")[0]
        else:
            return "N/A"

    def get_episode_from_title(self, item):
        # Patron para temporada y episodio "1x01"
        pattern = re.compile("([0-9]+)[ ]*[x|X][ ]*([0-9]+)")

        # Busca en title
        matches = pattern.findall(item.title)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en fulltitle
        matches = pattern.findall(item.fulltitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

        # Busca en contentTitle
        matches = pattern.findall(item.contentTitle)
        if len(matches):
            self.item_temporada = matches[0][0]
            self.item_episodio = matches[0][1]

    def get_item_info(self, item):
        # Recogemos los parametros del Item que nos interesan:
        self.item_title = item.title
        if item.fulltitle:
            self.item_title = item.fulltitle
        if item.contentTitle:
            self.item_title = item.contentTitle

        if item.show:
            self.item_serie = item.show
        if item.contentSerieName:
            self.item_serie = item.contentSerieName

        if item.contentSeason:
            self.item_temporada = item.contentSeason
        if item.contentEpisodeNumber:
            self.item_episodio = item.contentEpisodeNumber

        # i no existen contentepisodeNumber o contentSeason intenta sacarlo del titulo
        if not self.item_episodio or not self.item_temporada:
            self.get_episode_from_title(item)

    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

    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 get_tmdb_data(self, data_in):
        self.otmdb = None
        #logger.debug(str(data_in))

        if self.listData:
            infoLabels = InfoLabels()

            # Datos comunes a todos los listados
            infoLabels = Tmdb().get_infoLabels(infoLabels=infoLabels,
                                               origen=data_in)
            infoLabels["language"] = self.get_language(
                infoLabels["original_language"])
            infoLabels["puntuacion"] = str(
                data_in["vote_average"]) + "/10 (" + str(
                    data_in["vote_count"]) + ")"

            self.from_tmdb = False
            self.result = infoLabels

        else:
            if isinstance(data_in, Item):
                self.from_tmdb = True
                self.get_item_info(data_in)

                # Modo Pelicula
                if not self.item_serie:
                    encontrado = self.get_tmdb_movie_data(self.item_title)
                    if not encontrado:
                        encontrado = self.get_tmdb_tv_data(self.item_title)

                else:
                    encontrado = self.get_tmdb_tv_data(self.item_serie)
                    if not encontrado:
                        encontrado = self.get_tmdb_movie_data(self.item_serie)

            if isinstance(data_in, dict):
                self.from_tmdb = False
                self.result = InfoLabels(data_in)

        #logger.debug(str(self.result))

    def Start(self,
              data,
              caption="Información del vídeo",
              callback=None,
              item=None):
        # Capturamos los parametros
        self.caption = caption
        self.callback = callback
        self.item = item
        self.indexList = -1
        self.listData = None
        self.return_value = None

        # Obtenemos el canal desde donde se ha echo la llamada y cargamos los settings disponibles para ese canal
        channelpath = inspect.currentframe().f_back.f_back.f_code.co_filename
        self.channel = os.path.basename(channelpath).replace(".py", "")

        if type(data) == list:
            self.listData = data
            self.indexList = 0
            data = self.listData[self.indexList]

        self.get_tmdb_data(data)

        # Muestra la ventana
        self.doModal()
        return self.return_value

    def onInit(self):
        # Ponemos el foco en el boton de cerrar [X]
        self.setFocus(self.getControl(10003))

        # Ponemos el título y las imagenes
        self.getControl(10002).setLabel(self.caption)
        self.getControl(10004).setImage(self.result.get("fanart", ""))
        self.getControl(10005).setImage(
            self.result.get("thumbnail", "InfoWindow/img_no_disponible.png"))

        # Cargamos los datos para el formato pelicula
        if self.result.get("mediatype", "movie") == "movie":
            self.getControl(10006).setLabel("Titulo:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Titulo Original:")
            self.getControl(10009).setLabel(
                self.result.get("originaltitle", "N/A"))
            self.getControl(100010).setLabel("Idioma original:")
            self.getControl(100011).setLabel(self.result.get(
                "language", "N/A"))
            self.getControl(100012).setLabel("Puntuacion:")
            self.getControl(100013).setLabel(
                self.result.get("puntuacion", "N/A"))
            self.getControl(100014).setLabel("Lanzamiento:")
            self.getControl(100015).setLabel(
                self.result.get("release_date", "N/A"))
            self.getControl(100016).setLabel("Generos:")
            self.getControl(100017).setLabel(self.result.get("genre", "N/A"))

        # Cargamos los datos para el formato serie
        else:
            self.getControl(10006).setLabel("Serie:")
            self.getControl(10007).setLabel(self.result.get("title", "N/A"))
            self.getControl(10008).setLabel("Idioma original:")
            self.getControl(10009).setLabel(self.result.get("language", "N/A"))
            self.getControl(100010).setLabel("Puntuacion:")
            self.getControl(100011).setLabel(
                self.result.get("puntuacion", "N/A"))
            self.getControl(100012).setLabel("Generos:")
            self.getControl(100013).setLabel(self.result.get("genre", "N/A"))

            if self.result.get("season"):
                self.getControl(100014).setLabel("Titulo temporada:")
                self.getControl(100015).setLabel(
                    self.result.get("temporada_nombre", "N/A"))
                self.getControl(100016).setLabel("Temporada:")
                self.getControl(100017).setLabel(
                    self.result.get("season", "N/A") + " de " +
                    self.result.get("seasons", "N/A"))
            if self.result.get("episode"):
                self.getControl(100014).setLabel("Titulo:")
                self.getControl(100015).setLabel(
                    self.result.get("episode_title", "N/A"))
                self.getControl(100018).setLabel("Episodio:")
                self.getControl(100019).setLabel(
                    self.result.get("episode", "N/A") + " de " +
                    self.result.get("episodes", "N/A"))
                self.getControl(100020).setLabel("Emision:")
                self.getControl(100021).setLabel(self.result.get(
                    "date", "N/A"))

        # Sinopsis
        if self.result['plot']:
            self.getControl(100022).setLabel("Sinopsis:")
            self.getControl(100023).setText(self.result.get("plot", "N/A"))
        else:
            self.getControl(100022).setLabel("")
            self.getControl(100023).setText("")

        # Cargamos los botones si es necesario
        self.getControl(10024).setVisible(
            self.indexList > -1)  # Grupo de botones
        self.getControl(10025).setEnabled(self.indexList > 0)  #Anterior
        if self.listData:
            m = len(self.listData)
        else:
            m = 1
        self.getControl(10026).setEnabled(self.indexList + 1 != m)  # Siguiente
        self.getControl(100029).setLabel("(%s/%s)" %
                                         (self.indexList + 1, m))  # x/m

        # Ponemos el foco en el botón "Anterior",
        # si estuviera desactivado iria el foco al boton "Siguiente" y pasara lo mismo al botón "Cancelar"
        self.setFocus(self.getControl(10024))

    def onClick(self, id):
        logger.info("pelisalacarta.platformcode.xbmc_info_window onClick id=" +
                    repr(id))
        # Boton Cancelar y [X]
        if id == 10003 or id == 10027:
            self.close()

        # Boton Anterior
        if id == 10025 and self.indexList > 0:
            self.indexList -= 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Siguiente
        if id == 10026 and self.indexList < len(self.listData) - 1:
            self.indexList += 1
            self.get_tmdb_data(self.listData[self.indexList])
            self.onInit()

        # Boton Aceptar, Cancelar y [X]
        if id == 10028 or id == 10003 or id == 10027:
            self.close()

            if self.callback:
                cb_channel = None
                try:
                    cb_channel = __import__(
                        'core.%s' % self.channel,
                        fromlist=["core.%s" % self.channel])
                except ImportError:
                    logger.error('Imposible importar %s' % self.channel)

                if id == 10028:  # Boton Aceptar
                    if cb_channel:
                        self.return_value = getattr(cb_channel, self.callback)(
                            self.item, self.listData[self.indexList])
                else:  # Boton Cancelar y [X]
                    if cb_channel:
                        self.return_value = getattr(cb_channel,
                                                    self.callback)(self.item,
                                                                   None)

    def onAction(self, action):
        logger.info(
            "pelisalacarta.platformcode.xbmc_info_window onAction action=" +
            repr(action.getId()))

        # Accion 1: Flecha izquierda
        if action == 1:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Aceptar
            if focus == 10028:
                self.setFocus(self.getControl(10027))
            # botón Cancelar
            elif focus == 10027:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                elif self.indexList > 0:
                    # vamos al botón Anterior ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10025))
            # botón Siguiente
            elif focus == 10026:
                if self.indexList > 0:
                    # vamos al botón Anterior
                    self.setFocus(self.getControl(10025))

        # Accion 2: Flecha derecha
        if action == 2:
            # Obtenemos el foco
            focus = self.getFocusId()

            # botón Anterior
            if focus == 10025:
                if self.indexList + 1 != len(self.listData):
                    # vamos al botón Siguiente
                    self.setFocus(self.getControl(10026))
                else:
                    # vamos al botón Cancelar ya que Siguiente no está activo (estamos al final de la lista)
                    self.setFocus(self.getControl(10027))
            # botón Siguiente
            elif focus == 10026:
                self.setFocus(self.getControl(10027))
            # boton Cancelar
            elif focus == 10027:
                self.setFocus(self.getControl(10028))

        # Pulsa OK, simula click en boton aceptar
        # if action == 107: # es mover el ratón
        #     logger.info("onAction he pulstado ok")
        #     # self.onClick(10028)

        # Pulsa ESC o Atrás, simula click en boton cancelar
        if action in [10, 92]:
            # TODO arreglar
            # self.close()
            self.onClick(10027)
Exemple #48
0
def episodios(item):
    #import web_pdb; web_pdb.set_trace()
    logger.info()
    itemlist = []

    # Descarga la página
    data = httptools.downloadpage(item.url).data

    total_capis = scrapertools.get_match(
        data, "<input type='hidden' name='total_capis' value='(\d+)'>")
    tabla = scrapertools.get_match(
        data, "<input type='hidden' name='tabla' value='([^']+)'>")
    titulo = scrapertools.get_match(
        data, "<input type='hidden' name='titulo' value='([^']+)'>")

    item.thumbnail = scrapertools.find_single_match(
        data, "src='http://www\.mejortorrent\.com(/uploads/imagenes/" + tabla +
        "/[a-zA-Z0-9_ ]+.jpg)'")
    item.thumbnail = host + urllib.quote(item.thumbnail)

    # <form name='episodios' action='secciones.php?sec=descargas&ap=contar_varios' method='post'>
    data = scrapertools.get_match(
        data,
        "<form name='episodios' action='secciones.php\?sec=descargas\&ap=contar_varios' method='post'>(.*?)</form>"
    )
    if item.extra == "series":
        patron = "<td bgcolor[^>]+><a[^>]+>([^>]+)</a></td>[^<]+"
    else:
        patron = "<td bgcolor[^>]+>([^>]+)</td>[^<]+"

    patron += "<td[^<]+<div[^>]+>Fecha: ([^<]+)</div></td>[^<]+"
    patron += "<td[^<]+"
    patron += "<input type='checkbox' name='([^']+)' value='([^']+)'"

    matches = re.compile(patron, re.DOTALL).findall(data)

    tmdb_title = re.sub(
        r'(\s*-\s*)?\d+.*?\s*Temporada|(\s*-\s*)?\s*Miniserie\.?|\(.*\)|\[.*\]',
        '', item.title).strip()
    logger.debug('tmdb_title=' + tmdb_title)

    if item.extra == "series":
        oTmdb = Tmdb(texto_buscado=tmdb_title.strip(),
                     tipo='tv',
                     idioma_busqueda="es")
    else:
        oTmdb = Tmdb(texto_buscado=tmdb_title.strip(), idioma_busqueda="es")

    for scrapedtitle, fecha, name, value in matches:
        scrapedtitle = scrapedtitle.strip()
        if scrapedtitle.endswith('.'):
            scrapedtitle = scrapedtitle[:-1]
        #import web_pdb; web_pdb.set_trace()
        title = scrapedtitle + " (" + fecha + ")"
        patron = "<a href='(.*?)'>"

        url = "https://mejortorrent.website" + scrapertools.find_single_match(
            data, patron)
        # "episodios%5B1%5D=11744&total_capis=5&tabla=series&titulo=Sea+Patrol+-+2%AA+Temporada"
        post = urllib.urlencode({
            name: value,
            "total_capis": total_capis,
            "tabla": tabla,
            "titulo": titulo
        })
        logger.debug("post=" + post)

        if item.extra == "series":
            epi = scrapedtitle.split("x")

            # Sólo comprobar Tmdb si el formato es temporadaXcapitulo
            if len(epi) > 1:
                temporada = re.sub("\D", "", epi[0])
                capitulo = re.search("\d+", epi[1])
                if capitulo:
                    capitulo = capitulo.group()
                else:
                    capitulo = 1

                epi_data = oTmdb.get_episodio(temporada, capitulo)
                logger.debug("epi_data=" + str(epi_data))

                if epi_data:
                    item.thumbnail = epi_data["temporada_poster"]
                    item.fanart = epi_data["episodio_imagen"]
                    item.plot = epi_data["episodio_sinopsis"]
                    epi_title = epi_data["episodio_titulo"]
                    if epi_title != "":
                        title = scrapedtitle + " " + epi_title + " (" + fecha + ")"
        else:
            try:
                item.fanart = oTmdb.get_backdrop()
            except:
                pass

            item.plot = oTmdb.get_sinopsis()

        logger.debug("title=[" + title + "], url=[" + url + "], item=[" +
                     str(item) + "]")

        itemlist.append(
            Item(channel=item.channel,
                 action="play",
                 title=title,
                 url=url,
                 thumbnail=item.thumbnail,
                 plot=item.plot,
                 fanart=item.fanart,
                 extra=post,
                 folder=False,
                 id=value))

    return itemlist
Exemple #49
0
def getEpisodios (item):
    # Devuelve todos los capitulos de una serie
    logger.info("[peliserie.py] getEpisodios")
    itemlist = []  
    list_fanart=''
    
    # Buscamos el fanart en TMDB
    year=item.show.split('|')[1]
    item.show = item.show.split('|')[0]
    try:
        from core.tmdb import Tmdb
        oTmdb= Tmdb(texto_buscado=item.show,year=year,tipo="tv")
        item.fanart=oTmdb.get_backdrop()
    except:
        pass
  
    try:           
        data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)","",scrapertools.cache_page(item.url))
        sinopsis= scrapertools.entityunescape(scrapertools.get_match(data,'<p class="sinopsis">(.*?)</p>'))
        
        patron = '<div class="nav-pills(.*?)</div></div></div>'
        data = scrapertools.get_match(data,patron)
        patron= '<a href="([^"]+).*?' #url
        patron += '<strong>(\d+[x|X]\d+).*?</strong>.*?' #capitulo
        patron += '<img(.*?)</div>' # info:idiomas
        matches = re.compile(patron,re.DOTALL).findall(data)
        
        for url, capitulo, idiomas in matches:
            #logger.info("[peliserie.py] getEpisodios idiomas: " +idiomas)
            #idiomas = scrapertools.get_match(info,'src="(.*?)</div>')
            lang=[]
            if 'flag_0.png' in idiomas: lang.append('Es')
            if 'flag_1.png' in idiomas: lang.append('Lat')
            if 'flag_2.png' in idiomas: lang.append('VO')
            if 'flag_3.png' in idiomas: lang.append('VOSE')
            if len(lang) > 0:
                idiomas=' [' +  "/".join(lang)+']'
            else:
                idiomas=''
                    
            url=__url_base__ + url
            show = item.show
            title = show + ' ' + capitulo + idiomas
            action = "findvideos"
            
            try:
                # añadimos sinopsis e imagenes para cada capitulo
                temporada=capitulo.split('x')[0]
                episodio=oTmdb.get_episodio(temporada=capitulo.split('x')[0],capitulo=capitulo.split('x')[1])
                if episodio["episodio_sinopsis"] !="": sinopsis= episodio["episodio_sinopsis"]
                if episodio["episodio_imagen"] !="": item.thumbnail= episodio["episodio_imagen"]
                if episodio["episodio_titulo"] !="": title = title + ": " + episodio["episodio_titulo"]
            except:
                pass
            

            itemlist.append(Item(channel=__channel__, action=action, title=title, viewmode="movie_with_plot", url=url, show=show ,fanart= item.fanart, thumbnail= item.thumbnail,extra='series',plot=sinopsis))
        
        if config.get_library_support() and len(itemlist)>0 and item.extra.startswith("serie"):
            itemlist.append( Item(channel=__channel__, title="Añadir esta serie a la biblioteca", url=item.url, action="add_serie_to_library", extra='episodios###series', show= item.show))
    except:
        pass
        
    return itemlist 
def episodios(item):
    logger.info("pelisalacarta.mejortorrent episodios")
    itemlist = []

    # Descarga la página
    data = scrapertools.cachePage(item.url)

    total_capis = scrapertools.get_match(data,"<input type='hidden' name='total_capis' value='(\d+)'>")
    tabla = scrapertools.get_match(data,"<input type='hidden' name='tabla' value='([^']+)'>")
    titulo = scrapertools.get_match(data,"<input type='hidden' name='titulo' value='([^']+)'>")

    item.thumbnail = scrapertools.find_single_match(data, "src='http://www\.mejortorrent\.com(/uploads/imagenes/" + tabla + "/[a-zA-Z0-9_ ]+.jpg)'")
    item.thumbnail = 'http://www.mejortorrent.com' + urllib.quote(item.thumbnail)

    #<form name='episodios' action='secciones.php?sec=descargas&ap=contar_varios' method='post'>
    data = scrapertools.get_match(data,"<form name='episodios' action='secciones.php\?sec=descargas\&ap=contar_varios' method='post'>(.*?)</form>")
    '''
        <td bgcolor='#C8DAC8' style='border-bottom:1px solid black;'><a href='/serie-episodio-descargar-torrent-18741-Juego-de-tronos-4x01.html'>4x01 - Episodio en V.O. Sub Esp.</a></td>
        <td width='120' bgcolor='#C8DAC8' align='right' style='border-right:1px solid black; border-bottom:1px solid black;'><div style='color:#666666; font-size:9px; margin-right:5px;'>Fecha: 2014-04-07</div></td>
        <td width='60' bgcolor='#F1F1F1' align='center' style='border-bottom:1px solid black;'>
        <input type='checkbox' name='episodios[1]' value='18741'>
        '''

    if item.extra == "series":
        patron  = "<td bgcolor[^>]+><a[^>]+>([^>]+)</a></td>[^<]+"
    else:
        patron  = "<td bgcolor[^>]+>([^>]+)</td>[^<]+"


    patron += "<td[^<]+<div[^>]+>Fecha: ([^<]+)</div></td>[^<]+"
    patron += "<td[^<]+"
    patron += "<input type='checkbox' name='([^']+)' value='([^']+)'"

    matches = re.compile(patron,re.DOTALL).findall(data)
    scrapertools.printMatches(matches)

    tmdb_title = re.sub(r'(\s*-\s*)?\d+.*?\s*Temporada|(\s*-\s*)?\s*Miniserie\.?|\(.*\)|\[.*\]', '', item.title).strip()
    logger.debug('pelisalacarta.mejortorrent episodios tmdb_title=' + tmdb_title)

    if item.extra == "series":
        oTmdb= Tmdb(texto_buscado=tmdb_title.strip(), tipo='tv', idioma_busqueda="es")
    else:
        oTmdb= Tmdb(texto_buscado=tmdb_title.strip(), idioma_busqueda="es")

    for scrapedtitle,fecha,name,value in matches:
        scrapedtitle = scrapedtitle.strip()
        if scrapedtitle.endswith('.'):
            scrapedtitle = scrapedtitle[:-1]

        title = scrapedtitle + " (" + fecha + ")"

        url = "http://www.mejortorrent.com/secciones.php?sec=descargas&ap=contar_varios"
        #"episodios%5B1%5D=11744&total_capis=5&tabla=series&titulo=Sea+Patrol+-+2%AA+Temporada"
        post = urllib.urlencode( { name:value , "total_capis":total_capis , "tabla":tabla , "titulo":titulo } )
        logger.debug("post="+post)

        if item.extra == "series":
            epi = scrapedtitle.split("x")

            # Sólo comprobar Tmdb si el formato es temporadaXcapitulo
            if len(epi) > 1:
                temporada = re.sub("\D", "", epi[0])
                capitulo  = re.sub("\D", "", epi[1])

                epi_data = oTmdb.get_episodio(temporada, capitulo)
                logger.debug("epi_data=" + str(epi_data))

                if epi_data:
                    item.thumbnail = epi_data["temporada_poster"]
                    item.fanart = epi_data["episodio_imagen"]
                    item.plot = epi_data["episodio_sinopsis"]
                    epi_title = epi_data["episodio_titulo"]
                    if epi_title != "":
                        title = scrapedtitle + " " + epi_title + " (" + fecha + ")"
        else:
            try:
                item.fanart=oTmdb.get_backdrop()
            except:
                pass

            item.plot=oTmdb.get_sinopsis()

        logger.debug("title=["+title+"], url=["+url+"], item=["+str(item)+"]")

        itemlist.append( Item(channel=item.channel, action="play", title=title , url=url , thumbnail=item.thumbnail , plot=item.plot, fanart=item.fanart, extra=post, folder=False) )

    return itemlist
Exemple #51
0
def findvideos(item):
    logger.info("pelisalacarta.channels.seriecanal findvideos")
    itemlist = []
    data = scrapertools.cachePage(item.url)
    data = scrapertools.decodeHtmlentities(data)


    infoLabels={}
    plot={}
    infoLabels['season'] = item.extra
    infoLabels['plot'] = item.plot
    infoLabels['tvshowtitle']= item.fulltitle
    tmdbthumbnail = item.thumbnail
	
    #Busca en la seccion descarga/torrent
    data_download = scrapertools.get_match(data, '<th>Enlaces de Descarga mediante P2P o DD</th>(.*?)</table>')
    patron  = '<p class="item_name">.*?<a href="([^"]+)".*?">([^"]+)</a>'
    patron += '[^=]+.*?<a.*?">(.*?)</a>'
    matches = re.compile(patron,re.DOTALL).findall(data_download)
    scrapertools.printMatches(matches)
    for scrapedurl, scrapedepi, scrapedname in matches:
        if scrapedname != "Episodio "+scrapedepi : scrapedtitle = " - Episodio "+scrapedepi+" - "+scrapedname
        else: scrapedtitle = " - "+scrapedname
        scrapedtitle = scrapertools.htmlclean(scrapedtitle)
		#Info episodio
        infoLabels['episode']= scrapedepi
        try:
            from core.tmdb import Tmdb
            oTmdb= Tmdb(texto_buscado=item.fulltitle, tipo= "tv")
            episodio = oTmdb.get_episodio(infoLabels['season'], infoLabels['episode'])
            if episodio["episodio_sinopsis"] !="":
                infoLabels['plot'] = episodio["episodio_sinopsis"]
            infoLabels['genre'] = ", ".join(oTmdb.result["genres"])
            item.fanart=oTmdb.get_backdrop()
            tmdbthumbnail = episodio["episodio_imagen"]

        except:
            pass	

        plot['infoLabels']=infoLabels 
        if (DEBUG): logger.info("title=["+scrapedtitle+"], url=["+scrapedurl+"]")
        if scrapedurl.find("magnet") != -1:
            itemlist.append( Item(channel=__channel__, action="play" , title="[Torrent]" + scrapedtitle, url=scrapedurl, thumbnail=tmdbthumbnail  , plot = str(plot), fanart= item.fanart, extra="torrent"))

    #Busca en la seccion online
    data_online = scrapertools.get_match(data, '<th>Enlaces de Visionado Online</th>(.*?)</table>')
    patron  = '<a href="([^"]+)\\n.*?src="([^"]+)".*?'
    patron += 'title="Enlace de Visionado Online">([^"]+)</a>'
    matches = re.compile(patron,re.DOTALL).findall(data_online)
    scrapertools.printMatches(matches)
    
    for scrapedurl, scrapedthumb, scrapedtitle in matches:
        #Deshecha enlaces de trailers
        scrapedtitle = scrapertools.htmlclean(scrapedtitle)
        if (scrapedthumb != "images/series/youtube.png") & (scrapedtitle!="Trailer"):
            server = scrapertools.find_single_match(scrapedthumb, 'images/series/(.*?).png')
            scrapedepi = scrapertools.find_single_match(scrapedtitle, 'Episodio (.*?) -')
            title = "["+server.capitalize()+"]"+" "+scrapedtitle
			#Info episodio
            infoLabels['episode']= scrapedepi
            try:
                from core.tmdb import Tmdb
                oTmdb= Tmdb(texto_buscado=item.fulltitle, tipo= "tv")
                episodio = oTmdb.get_episodio(infoLabels['season'], infoLabels['episode'])
                if episodio["episodio_sinopsis"] !="":
                    infoLabels['plot'] = episodio["episodio_sinopsis"]
                infoLabels['genre'] = ", ".join(oTmdb.result["genres"])
                item.fanart=oTmdb.get_backdrop()
                tmdbthumbnail = episodio["episodio_imagen"]
            except:
                pass	

            plot['infoLabels']=infoLabels 
            itemlist.append( Item(channel=__channel__, action="play" , extra=server, title=title, url=scrapedurl, thumbnail=tmdbthumbnail , fanart=item.fanart, plot = str(plot)))				

    data_temp = scrapertools.get_match(data, '<div class="panel panel-success">(.*?)</table>')
    data_temp = re.sub(r"\n|\r|\t|\s{2}|&nbsp;","",data_temp)
    data_notemp = scrapertools.find_single_match(data_temp, '<td colspan="7"(.*?)</table>')
    #Comprueba si hay otras temporadas
    if len(data_notemp) == 0:
        patron  = '<tr><td><p class="item_name"><a href="([^"]+)".*?'
        patron += '<p class="text-success"><strong>([^"]+)</strong>'
        matches = re.compile(patron,re.DOTALL).findall(data_temp)
        scrapertools.printMatches(matches)
        for scrapedurl, scrapedtitle in matches:
            url = urlparse.urljoin(URL_BASE, scrapedurl)
            scrapedtitle = scrapedtitle.capitalize()
            itemlist.append( Item(channel=__channel__, action="findvideos", title=scrapedtitle , fulltitle=item.fulltitle, url=url , thumbnail=item.thumbnail, extra=scrapedtitle.strip("Temporada "), fanart=item.fanart, plot=item.plot, folder=True))

    return itemlist
Exemple #52
0
def episodios(item):
    logger.info("pelisalacarta.mejortorrent episodios")
    itemlist = []

    # Descarga la página
    data = scrapertools.cachePage(item.url)

    total_capis = scrapertools.get_match(
        data, "<input type='hidden' name='total_capis' value='(\d+)'>")
    tabla = scrapertools.get_match(
        data, "<input type='hidden' name='tabla' value='([^']+)'>")
    titulo = scrapertools.get_match(
        data, "<input type='hidden' name='titulo' value='([^']+)'>")

    item.thumbnail = scrapertools.find_single_match(
        data, "src='http://www\.mejortorrent\.com(/uploads/imagenes/" + tabla +
        "/[a-zA-Z0-9_ ]+.jpg)'")
    item.thumbnail = 'http://www.mejortorrent.com' + urllib.quote(
        item.thumbnail)

    #<form name='episodios' action='secciones.php?sec=descargas&ap=contar_varios' method='post'>
    data = scrapertools.get_match(
        data,
        "<form name='episodios' action='secciones.php\?sec=descargas\&ap=contar_varios' method='post'>(.*?)</form>"
    )
    '''
        <td bgcolor='#C8DAC8' style='border-bottom:1px solid black;'><a href='/serie-episodio-descargar-torrent-18741-Juego-de-tronos-4x01.html'>4x01 - Episodio en V.O. Sub Esp.</a></td>
        <td width='120' bgcolor='#C8DAC8' align='right' style='border-right:1px solid black; border-bottom:1px solid black;'><div style='color:#666666; font-size:9px; margin-right:5px;'>Fecha: 2014-04-07</div></td>
        <td width='60' bgcolor='#F1F1F1' align='center' style='border-bottom:1px solid black;'>
        <input type='checkbox' name='episodios[1]' value='18741'>
        '''

    if item.extra == "series":
        patron = "<td bgcolor[^>]+><a[^>]+>([^>]+)</a></td>[^<]+"
    else:
        patron = "<td bgcolor[^>]+>([^>]+)</td>[^<]+"

    patron += "<td[^<]+<div[^>]+>Fecha: ([^<]+)</div></td>[^<]+"
    patron += "<td[^<]+"
    patron += "<input type='checkbox' name='([^']+)' value='([^']+)'"

    matches = re.compile(patron, re.DOTALL).findall(data)
    scrapertools.printMatches(matches)

    tmdb_title = re.sub(
        r'(\s*-\s*)?\d+.*?\s*Temporada|(\s*-\s*)?\s*Miniserie\.?|\(.*\)|\[.*\]',
        '', item.title).strip()
    logger.debug('pelisalacarta.mejortorrent episodios tmdb_title=' +
                 tmdb_title)

    if item.extra == "series":
        oTmdb = Tmdb(texto_buscado=tmdb_title.strip(),
                     tipo='tv',
                     idioma_busqueda="es")
    else:
        oTmdb = Tmdb(texto_buscado=tmdb_title.strip(), idioma_busqueda="es")

    for scrapedtitle, fecha, name, value in matches:
        scrapedtitle = scrapedtitle.strip()
        if scrapedtitle.endswith('.'):
            scrapedtitle = scrapedtitle[:-1]

        title = scrapedtitle + " (" + fecha + ")"

        url = "http://www.mejortorrent.com/secciones.php?sec=descargas&ap=contar_varios"
        #"episodios%5B1%5D=11744&total_capis=5&tabla=series&titulo=Sea+Patrol+-+2%AA+Temporada"
        post = urllib.urlencode({
            name: value,
            "total_capis": total_capis,
            "tabla": tabla,
            "titulo": titulo
        })
        logger.debug("post=" + post)

        if item.extra == "series":
            epi = scrapedtitle.split("x")

            # Sólo comprobar Tmdb si el formato es temporadaXcapitulo
            if len(epi) > 1:
                temporada = re.sub("\D", "", epi[0])
                capitulo = re.search("\d+", epi[1])
                if capitulo:
                    capitulo = capitulo.group()
                else:
                    capitulo = 1

                epi_data = oTmdb.get_episodio(temporada, capitulo)
                logger.debug("epi_data=" + str(epi_data))

                if epi_data:
                    item.thumbnail = epi_data["temporada_poster"]
                    item.fanart = epi_data["episodio_imagen"]
                    item.plot = epi_data["episodio_sinopsis"]
                    epi_title = epi_data["episodio_titulo"]
                    if epi_title != "":
                        title = scrapedtitle + " " + epi_title + " (" + fecha + ")"
        else:
            try:
                item.fanart = oTmdb.get_backdrop()
            except:
                pass

            item.plot = oTmdb.get_sinopsis()

        logger.debug("title=[" + title + "], url=[" + url + "], item=[" +
                     str(item) + "]")

        itemlist.append(
            Item(channel=item.channel,
                 action="play",
                 title=title,
                 url=url,
                 thumbnail=item.thumbnail,
                 plot=item.plot,
                 fanart=item.fanart,
                 extra=post,
                 folder=False))

    return itemlist
    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
Exemple #54
0
def episodios(item):
    logger.info("pelisalacarta.channels.verseriesynovelas episodios")
    itemlist = []

    data = anti_cloudflare(item.url)
    data = data.replace("\n", "").replace("\t", "")
    if item.show == "":
        try:
            from core.tmdb import Tmdb
            otmdb = Tmdb(texto_buscado=item.fulltitle, tipo="tv")
        except:
            pass
    plot = scrapertools.find_single_match(data, '<p><p>(.*?)</p>')
    if len(plot) > 0: plot = scrapertools.htmlclean(plot)
    patron = '<td data-th="Temporada"(.*?)</div>'
    bloque = scrapertools.find_multiple_matches(data, patron)
    for match in bloque:
        patron = '.*?href="([^"]+)".*?title="([^"]+)"'
        matches = scrapertools.find_multiple_matches(match, patron)
        for scrapedurl, scrapedtitle in matches:
            if item.show == "":
                try:
                    sinopsis, fanart, thumbnail = infoepi(
                        otmdb,
                        scrapedtitle.rsplit(' ', 1)[1], plot)
                    if thumbnail == "": thumbnail = item.thumbnail
                except:
                    thumbnail = item.thumbnail
                    fanart = item.fanart
                    sinopsis = plot
                    pass
            else:
                thumbnail = item.thumbnail
                fanart = item.fanart
                sinopsis = plot
            scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle) + " "
            scrapedtitle = scrapedtitle.replace('Temporada', '')
            if "ES.png" in match:
                scrapedtitle += "[COLOR sandybrown][CAST][/COLOR]"
            if "SUB.png" in match:
                scrapedtitle += "[COLOR green][VOSE][/COLOR]"
            if "LA.png" in match: scrapedtitle += "[COLOR red][LAT][/COLOR]"
            if "EN.png" in match: scrapedtitle += "[COLOR blue][V.O][/COLOR]"
            if (DEBUG):
                logger.info("title=[" + scrapedtitle + "], url=[" +
                            scrapedurl + "]")
            if item.show != "":
                scrapedtitle = scrapedurl + "%" + scrapedtitle
                scrapedurl = item.url
            itemlist.append(
                Item(channel=__channel__,
                     action='findvideos',
                     title=scrapedtitle,
                     url=scrapedurl,
                     thumbnail=thumbnail,
                     fanart=fanart,
                     fulltitle=item.fulltitle,
                     plot=str(sinopsis),
                     show=item.show,
                     folder=True))

    if len(itemlist) > 0 and item.show == "":
        if config.get_library_support():
            itemlist.append(
                Item(
                    channel=__channel__,
                    title=
                    "[COLOR green]Añadir esta temporada a la biblioteca[/COLOR]",
                    url=item.url,
                    action="add_serie_to_library",
                    extra="episodios",
                    fulltitle=item.fulltitle,
                    show=item.fulltitle))

    return itemlist