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, type, sinopsis):
logger.info("pelisalacarta.descargasmix info")
infolabels = {}
plot = {}
try:
from core.tmdb import Tmdb
otmdb = Tmdb(texto_buscado=title, tipo=type)
if otmdb.get_sinopsis() == "": infolabels['plot'] = sinopsis
else: infolabels['plot'] = otmdb.get_sinopsis()
infolabels['year'] = otmdb.result["release_date"][:4]
infolabels['genre'] = otmdb.get_generos()
infolabels['rating'] = float(otmdb.result["vote_average"])
fanart = otmdb.get_backdrop()
plot['infoLabels'] = infolabels
return plot, fanart
except:
pass
def info(title):
logger.info("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
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
logger.debug("data=" + 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
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=item.channel,
action="play",
server="torrent",
title=item.title,
url=link,
thumbnail=item.thumbnail,
plot=item.plot,
fanart=item.fanart,
folder=False))
return itemlist
def info(title):
logger.info("streamondemand.italiafilmvideohd info")
try:
from core.tmdb import Tmdb
oTmdb = Tmdb(texto_buscado=title,
tipo="movie",
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 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 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 completar_codigos(item):
"""
Si es necesario comprueba si existe el identificador de tmdb y sino existe trata de buscarlo
@param item: tipo item
@type item: Item
"""
if not item.infoLabels['tmdb_id']:
listsources = [(item.infoLabels['tvdb_id'], "tvdb_id")]
if item.infoLabels['imdb_id']:
listsources.append((item.infoLabels['imdb_id'], "imdb_id"))
from core.tmdb import Tmdb
ob = Tmdb()
for external_id, external_source in listsources:
ob.search_by_id(id=external_id, source=external_source, tipo='tv')
item.infoLabels['tmdb_id'] = ob.get_id()
if item.infoLabels['tmdb_id']:
url_scraper = "https://www.themoviedb.org/tv/%s" % item.infoLabels['tmdb_id']
item.infoLabels['url_scraper'].append(url_scraper)
break
def get_tmdb_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["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 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
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
def find_and_set_infoLabels(item):
"""
función que se llama para buscar y setear los infolabels
:param item:
:return:
"""
global scraper_global
logger.debug("item:\n" + item.tostring('\n'))
params = {}
if item.contentType == "movie":
tipo_contenido = "pelicula"
title = item.contentTitle
# get scraper pelis
scraper = Tmdb()
# para tmdb
tipo_busqueda = "movie"
else:
tipo_contenido = "serie"
title = item.contentSerieName
# get scraper series
scraper = Tmdb()
# para tmdb
tipo_busqueda = "tv"
# esto ya está en el scraper tmdb
# title = re.sub('\[\\\?(B|I|COLOR)\s?[^\]]*\]', '', title)
# Si el titulo incluye el (año) se lo quitamos
year = scrapertools.find_single_match(title, "^.+?\s*(\(\d{4}\))$")
if year:
title = title.replace(year, "").strip()
item.infoLabels['year'] = year[1:-1]
scraper_result = None
results = []
while not scraper_result:
# para tmdb
if isinstance(scraper, Tmdb):
logger.debug("scraper es Tmbdb")
params["texto_buscado"] = title
params["tipo"] = tipo_busqueda
params["year"] = item.infoLabels['year']
if not results:
if not item.infoLabels.get("tmdb_id"):
if not item.infoLabels.get("imdb_id"):
scraper_global = scraper(**params)
else:
logger.info("tiene imdb")
# para tmdb
if isinstance(scraper, Tmdb):
params["external_id"] = item.infoLabels.get("imdb_id")
params["external_source"] = "imdb_id"
scraper_global = scraper(**params)
elif not scraper_global or scraper_global.result.get(
"id") != item.infoLabels['tmdb_id']:
# para tmdb
if isinstance(scraper, Tmdb):
params["id_Tmdb"] = item.infoLabels['tmdb_id']
params["idioma_busqueda"] = "es"
scraper_global = scraper(**params)
results = scraper_global.get_list_resultados()
if len(results) > 1:
scraper_result = platformtools.show_video_info(
results,
item=item,
scraper=scraper,
caption="[%s]: Selecciona la %s correcta" %
(title, tipo_contenido))
elif len(results) > 0:
scraper_result = results[0]
if scraper_result is None:
index = -1
if tipo_contenido == "serie":
# Si no lo encuentra la serie por si solo, presentamos una lista de opciones
opciones = ["Introducir otro nombre", "Buscar en TheTvDB.com"]
index = platformtools.dialog_select(
"%s no encontrada" % tipo_contenido.capitalize(), opciones)
elif platformtools.dialog_yesno(
"Película no encontrada",
"No se ha encontrado la película:", title,
'¿Desea introducir otro nombre?'):
index = 0
if index < 0:
logger.debug(
"he pulsado 'cancelar' en la ventana '%s no encontrada'" %
tipo_contenido.capitalize())
break
if index == 0: # "Introducir otro nombre"
# Pregunta el titulo
it = platformtools.dialog_input(
title,
"Introduzca el nombre de la %s a buscar" % tipo_contenido)
if it is not None:
title = it
item.infoLabels['year'] = ""
# reseteamos los resultados
results = []
else:
logger.debug(
"he pulsado 'cancelar' en la ventana 'introduzca el nombre correcto'"
)
break
if index == 1: # "Buscar en TheTvDB.com"
results = tvdb_series_by_title(title)
if isinstance(item.infoLabels, InfoLabels):
infoLabels = item.infoLabels
else:
infoLabels = InfoLabels()
if scraper_result:
if 'id' in scraper_result:
# resultados obtenidos de tmdb
infoLabels['tmdb_id'] = scraper_result['id']
infoLabels[
'url_scraper'] = "https://www.themoviedb.org/tv/%s" % infoLabels[
'tmdb_id']
item.infoLabels = infoLabels
tmdb.set_infoLabels_item(item)
elif 'tvdb_id' in scraper_result:
# resultados obtenidos de tvdb
infoLabels.update(scraper_result)
item.infoLabels = infoLabels
# logger.debug("item:\n" + item.tostring('\n'))
return True
else:
item.infoLabels = infoLabels
return False
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 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 get_only_episodio(item):
logger.info("[pepecine.py] get_only_episodio")
itemlist = []
plot = {}
data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "",
scrapertools.cache_page(item.url))
patron = 'vars.title =(.*?)};'
try:
data_dict = jsontools.load_json(
scrapertools.get_match(data, patron) + '}')
except:
return itemlist # Devolvemos lista vacia
try:
from core.tmdb import Tmdb
oTmdb = Tmdb(id_Tmdb=data_dict['tmdb_id'], tipo="tv")
except:
pass
infoLabels = item.infoLabels
cast = []
rol = []
for actor in data_dict["actor"]:
cast.append(actor['name'])
rol.append(actor['pivot']['char_name'])
writers_list = []
for writer in data_dict["writer"]:
writers_list.append(writer['name'])
director_list = []
for director in data_dict["director"]:
director_list.append(director['name'])
infoLabels['cast'] = cast
infoLabels['castandrole'] = zip(cast, rol)
infoLabels['writer'] = ", ".join(writers_list)
infoLabels['director'] = ", ".join(director_list)
infoLabels['season'], infoLabels['episode'] = item.extra.split('x')
try:
# añadimos sinopsis e imagenes del capitulo
datos_tmdb = oTmdb.get_episodio(temporada=infoLabels['season'],
capitulo=infoLabels['episode'])
if datos_tmdb["episodio_sinopsis"] != "":
infoLabels['plot'] = datos_tmdb["episodio_sinopsis"]
if datos_tmdb["episodio_imagen"] != "":
item.thumbnail = datos_tmdb["episodio_imagen"]
#if datos_tmdb["episodio_titulo"] !="": title = title + " [COLOR 0xFFFFE6CC]" + datos_tmdb["episodio_titulo"].replace('\t','') + "[/COLOR]"
except:
pass
def cap(l):
try:
temporada_link = int(l["season"])
capitulo_link = int(l['episode'])
except:
return False
return True if temporada_link == int(
infoLabels['season']) and capitulo_link == int(
infoLabels['episode']) else False
item.url = str(filter(cap,
data_dict["link"])) #filtramos enlaces por capitulo
item.infoLabels = infoLabels
item.extra = str(data_dict['tmdb_id'])
return findvideos(item)
def 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, 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="it",
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="it", 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_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 = 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__, "series-online/" + str(title_id))
#url= urlparse.urljoin(__url_base__,"series-online/" + (str(infoLabels['title_id']) +"-"+ infoLabels['titleraw']))
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://d5.usercdn.com/dl/i/02360/a99fzwbqdaen.png'
))
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
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
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
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
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
seriethumbnail = item.thumbnail
try:
from core.tmdb import Tmdb
oTmdb = Tmdb(texto_buscado=item.fulltitle, tipo="tv")
except:
pass
#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:
thumbnail_epi = ""
episodio = oTmdb.get_episodio(infoLabels['season'],
infoLabels['episode'])
if episodio["episodio_sinopsis"] != "":
infoLabels['plot'] = episodio["episodio_sinopsis"]
else:
if oTmdb.get_sinopsis() != "":
infoLabels['plot'] = oTmdb.get_sinopsis()
infoLabels['genre'] = ", ".join(oTmdb.result["genres"])
item.fanart = oTmdb.get_backdrop()
if episodio["episodio_imagen"] != "":
thumbnail_epi = episodio["episodio_imagen"]
except:
pass
plot['infoLabels'] = infoLabels
if (DEBUG):
logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl +
"]")
if scrapedurl.find("magnet") != -1:
if thumbnail_epi == "": thumbnail_epi = seriethumbnail
itemlist.append(
Item(channel=__channel__,
action="play",
title="[Torrent]" + scrapedtitle,
url=scrapedurl,
thumbnail=thumbnail_epi,
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:
thumbnail_epi = ""
episodio = oTmdb.get_episodio(infoLabels['season'],
infoLabels['episode'])
if episodio["episodio_sinopsis"] != "":
infoLabels['plot'] = episodio["episodio_sinopsis"]
else:
if oTmdb.get_sinopsis() != "":
infoLabels['plot'] = oTmdb.get_sinopsis()
infoLabels['genre'] = ", ".join(oTmdb.result["genres"])
item.fanart = oTmdb.get_backdrop()
if episodio["episodio_imagen"] != "":
thumbnail_epi = episodio["episodio_imagen"]
except:
pass
plot['infoLabels'] = infoLabels
if thumbnail_epi == "": thumbnail_epi = seriethumbnail
itemlist.append(
Item(channel=__channel__,
action="play",
extra=server,
title=title,
url=scrapedurl,
thumbnail=thumbnail_epi,
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}| ", "", 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=seriethumbnail,
extra=scrapedtitle.strip("Temporada "),
fanart=item.fanart,
plot=item.plot,
folder=True))
return itemlist
