1533 lines
93 KiB
Python
1533 lines
93 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import re
|
|
import sys
|
|
import urllib
|
|
import urlparse
|
|
|
|
from channelselector import get_thumb
|
|
from core import httptools
|
|
from core import scrapertools
|
|
from core import servertools
|
|
from core.item import Item
|
|
from platformcode import config, logger
|
|
from core import tmdb
|
|
|
|
host = 'http://mispelisyseries.com/'
|
|
|
|
def mainlist(item):
|
|
logger.info()
|
|
|
|
itemlist = []
|
|
|
|
thumb_pelis = get_thumb("channels_movie.png")
|
|
thumb_pelis_hd = get_thumb("channels_movie_hd.png")
|
|
thumb_series = get_thumb("channels_tvshow.png")
|
|
thumb_series_hd = get_thumb("channels_tvshow_hd.png")
|
|
thumb_series_az = get_thumb("channels_tvshow_az.png")
|
|
thumb_docus = get_thumb("channels_documentary.png")
|
|
thumb_buscar = get_thumb("search.png")
|
|
thumb_settings = get_thumb("setting_0.png")
|
|
|
|
itemlist.append(Item(channel=item.channel, action="submenu", title="Películas", url=host,
|
|
extra="peliculas", thumbnail=thumb_pelis ))
|
|
|
|
itemlist.append(Item(channel=item.channel, action="submenu", title="Series", url=host, extra="series",
|
|
thumbnail=thumb_series))
|
|
|
|
itemlist.append(Item(channel=item.channel, action="submenu", title="Documentales", url=host, extra="varios",
|
|
thumbnail=thumb_docus))
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="search", title="Buscar", url=host + "buscar", thumbnail=thumb_buscar))
|
|
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="", title="[COLOR yellow]Configuración de Servidores:[/COLOR]", url="", thumbnail=thumb_settings))
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="settingCanal", title="Servidores para Ver Online y Descargas", url="", thumbnail=thumb_settings))
|
|
|
|
return itemlist
|
|
|
|
|
|
def settingCanal(item):
|
|
from platformcode import platformtools
|
|
return platformtools.show_channel_settings()
|
|
|
|
|
|
def submenu(item):
|
|
logger.info()
|
|
itemlist = []
|
|
|
|
data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
|
|
data = unicode(data, "iso-8859-1", errors="replace").encode("utf-8")
|
|
data = data.replace("'", '"').replace('/series"', '/series/"') #Compatibilidad con mispelisy.series.com
|
|
|
|
host_dom = host.replace("https://", "").replace("http://", "").replace("www.", "")
|
|
patron = '<li><a href="http://(?:www.)?' + host_dom + item.extra + '/">.*?<ul.*?>(.*?)</ul>'
|
|
if "pelisyseries.com" in host and item.extra == "varios": #compatibilidad con mispelisy.series.com
|
|
data = '<a href="' + host + 'varios/" title="Documentales"><i class="icon-rocket"></i> Documentales</a>'
|
|
else:
|
|
if data:
|
|
data = scrapertools.get_match(data, patron)
|
|
else:
|
|
return itemlist
|
|
|
|
patron = '<.*?href="([^"]+)".*?>([^>]+)</a>'
|
|
matches = re.compile(patron, re.DOTALL).findall(data)
|
|
|
|
for scrapedurl, scrapedtitle in matches:
|
|
title = scrapedtitle.strip()
|
|
url = scrapedurl
|
|
|
|
itemlist.append(Item(channel=item.channel, action="listado", title=title, url=url, extra=item.extra))
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="alfabeto", title=title + " [A-Z]", url=url, extra=item.extra))
|
|
|
|
if item.extra == "peliculas":
|
|
itemlist.append(Item(channel=item.channel, action="listado", title="Películas 4K", url=host + "peliculas-hd/4kultrahd/", extra=item.extra))
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="alfabeto", title="Películas 4K" + " [A-Z]", url=host + "peliculas-hd/4kultrahd/", extra=item.extra))
|
|
|
|
return itemlist
|
|
|
|
|
|
def alfabeto(item):
|
|
logger.info()
|
|
itemlist = []
|
|
|
|
data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
|
|
data = unicode(data, "iso-8859-1", errors="replace").encode("utf-8")
|
|
|
|
patron = '<ul class="alfabeto">(.*?)</ul>'
|
|
if data:
|
|
data = scrapertools.get_match(data, patron)
|
|
else:
|
|
return itemlist
|
|
|
|
patron = '<a href="([^"]+)"[^>]+>([^>]+)</a>'
|
|
|
|
matches = re.compile(patron, re.DOTALL).findall(data)
|
|
|
|
for scrapedurl, scrapedtitle in matches:
|
|
title = scrapedtitle.upper()
|
|
url = scrapedurl
|
|
|
|
itemlist.append(Item(channel=item.channel, action="listado", title=title, url=url, extra=item.extra))
|
|
|
|
return itemlist
|
|
|
|
|
|
def listado(item):
|
|
logger.info()
|
|
itemlist = []
|
|
clase = "pelilist" # etiqueta para localizar zona de listado de contenidos
|
|
url_next_page ='' # Controlde paginación
|
|
cnt_tot = 30 # Poner el num. máximo de items por página
|
|
category = "" # Guarda la categoria que viene desde una busqueda global
|
|
|
|
if item.category:
|
|
category = item.category
|
|
del item.category
|
|
if item.totalItems:
|
|
del item.totalItems
|
|
|
|
data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
|
|
|
|
#Establecemos los valores básicos en función del tipo de contenido
|
|
if item.extra == "peliculas":
|
|
item.action = "findvideos"
|
|
item.contentType = "movie"
|
|
pag = True #Sí hay paginación
|
|
elif item.extra == "series" and not "/miniseries" in item.url:
|
|
item.action = "episodios"
|
|
item.contentType = "tvshow"
|
|
pag = True
|
|
elif item.extra == "varios" or "/miniseries" in item.url:
|
|
item.action = "findvideos"
|
|
item.contentType = "movie"
|
|
pag = True
|
|
|
|
#Selecciona el tramo de la página con el listado de contenidos
|
|
patron = '<ul class="' + clase + '">(.*?)</ul>'
|
|
if data:
|
|
fichas = scrapertools.get_match(data, patron)
|
|
else:
|
|
return itemlist
|
|
page_extra = clase
|
|
|
|
#Scrapea los datos de cada vídeo. Título alternativo se mantiene, aunque no se usa de momento
|
|
patron = '<a href="([^"]+).*?' # la url
|
|
patron += 'title="([^"]+).*?' # el titulo
|
|
patron += '<img.*?src="([^"]+)"[^>]+>.*?' # el thumbnail
|
|
patron += '<h2.*?>(.*?)?<\/h2>' # titulo alternativo. Se trunca en títulos largos
|
|
patron += '<span>([^<].*?)?<' # la calidad
|
|
matches = re.compile(patron, re.DOTALL).findall(fichas)
|
|
#logger.debug("MATCHES: " + str(len(matches)))
|
|
#logger.debug(matches)
|
|
#logger.debug("patron: " + patron + " / fichas: " + fichas)
|
|
|
|
# Identifico la página actual y el total de páginas para el pie de página
|
|
total_pag = scrapertools.find_single_match(data,'<a href=".*?(\d+)?">Last<\/a><\/li>')
|
|
|
|
if not item.post_num:
|
|
post_num = 1
|
|
else:
|
|
post_num = int(item.post_num) + 1
|
|
if not total_pag:
|
|
total_pag = 1
|
|
#Calcula las páginas del canal por cada página de la web
|
|
total_pag = int(total_pag) * int((float(len(matches))/float(cnt_tot)) + 0.999999)
|
|
|
|
# Preparamos la paginación.
|
|
if not item.cnt_pag:
|
|
cnt_pag = 0
|
|
else:
|
|
cnt_pag = item.cnt_pag
|
|
del item.cnt_pag
|
|
|
|
matches_cnt = len(matches)
|
|
if item.next_page != 'b':
|
|
if matches_cnt > cnt_pag + cnt_tot:
|
|
url_next_page = item.url
|
|
matches = matches[cnt_pag:cnt_pag+cnt_tot]
|
|
next_page = ''
|
|
if matches_cnt <= cnt_pag + (cnt_tot * 2):
|
|
if pag:
|
|
next_page = 'b'
|
|
modo = 'continue'
|
|
else:
|
|
matches = matches[cnt_pag:cnt_pag+cnt_tot]
|
|
next_page = 'a'
|
|
patron_next_page = '<a href="([^"]+)">Next<\/a>'
|
|
matches_next_page = re.compile(patron_next_page, re.DOTALL).findall(data)
|
|
modo = 'continue'
|
|
if len(matches_next_page) > 0:
|
|
url_next_page = urlparse.urljoin(item.url, matches_next_page[0])
|
|
modo = 'next'
|
|
|
|
# Avanzamos el contador de líneas en una página
|
|
if item.next_page:
|
|
del item.next_page
|
|
if modo == 'next':
|
|
cnt_pag = 0
|
|
else:
|
|
cnt_pag += cnt_tot
|
|
|
|
#Tratamos todos los contenidos, creardo una variable local de Item
|
|
for scrapedurl, scrapedtitle, scrapedthumbnail, title_alt, calidad in matches:
|
|
item_local = item.clone()
|
|
if item_local.tipo:
|
|
del item_local.tipo
|
|
if item_local.totalItems:
|
|
del item_local.totalItems
|
|
if item.post_num:
|
|
del item.post_num
|
|
|
|
item_local.title = ''
|
|
item_local.context = "['buscar_trailer']"
|
|
|
|
# Limpiamos títulos, Sacamos datos de calidad, audio y lenguaje
|
|
title = re.sub('\r\n', '', scrapedtitle).decode('iso-8859-1').encode('utf8').strip()
|
|
title_alt = re.sub('\r\n', '', title_alt).decode('iso-8859-1').encode('utf8').strip()
|
|
title = title.replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o").replace("ú", "u").replace("ü", "u").replace("�", "ñ").replace("ñ", "ñ").replace(".", " ")
|
|
title_alt = title_alt.replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o").replace("ú", "u").replace("ü", "u").replace("�", "ñ").replace("ñ", "ñ")
|
|
|
|
item_local.quality = calidad
|
|
title_subs = []
|
|
|
|
#Determinamos y marcamos idiomas distintos del castellano
|
|
item_local.language = []
|
|
if "[vos" in title.lower() or "v.o.s" in title.lower() or "vo" in title.lower() or ".com/pelicula/" in scrapedurl or ".com/series-vo" in scrapedurl or "-vo/" in scrapedurl or "vos" in calidad.lower() or "vose" in calidad.lower() or "v.o.s" in calidad.lower() or "sub" in calidad.lower() or ".com/peliculas-vo" in item.url:
|
|
item_local.language += ["VOS"]
|
|
title = title.replace(" [Subs. integrados]", "").replace(" [subs. Integrados]", "").replace(" [VOSE", "").replace(" [VOS", "").replace(" (V.O.S.E)", "").replace(" VO", "").replace("Subtitulos", "")
|
|
if "latino" in title.lower() or "argentina" in title.lower() or "-latino/" in scrapedurl or "latino" in calidad.lower() or "argentina" in calidad.lower():
|
|
item_local.language += ["LAT"]
|
|
|
|
#Guardamos info de 3D en calidad y limpiamos
|
|
if "3d" in title.lower():
|
|
if not "3d" in item_local.quality.lower():
|
|
item_local.quality = item_local.quality + " 3D"
|
|
calidad3D = scrapertools.find_single_match(title, r'\s(3[d|D]\s\w+)')
|
|
if calidad3D:
|
|
item_local.quality = item_local.quality.replace("3D", calidad3D)
|
|
title = re.sub(r'\s3[d|D]\s\w+', '', title)
|
|
title = re.sub(r'\s3[d|D]', '', title)
|
|
title_alt = re.sub(r'\s3[d|D]\s\w+', '', title_alt)
|
|
title_alt = re.sub(r'\s3[d|D]', '', title_alt)
|
|
if "imax" in title.lower():
|
|
item_local.quality = item_local.quality + " IMAX"
|
|
title = title.replace(" IMAX", "").replace(" imax", "")
|
|
title_alt = title_alt.replace(" IMAX", "").replace(" imax", "")
|
|
if "2d" in title.lower():
|
|
title = title.replace("(2D)", "").replace("(2d)", "").replace("2D", "").replace("2d", "")
|
|
title_subs += ["[2D]"]
|
|
|
|
#Extraemos info adicional del título y la guardamos para después de TMDB
|
|
if "temp" in title.lower() or "cap" in title.lower(): #Eliminamos Temporada, solo nos interesa la serie completa
|
|
title = re.sub(r' - [t|T]emp\w+ \d+x\d+', '', title)
|
|
title = re.sub(r' - [t|T]emp\w+ \d+', '', title)
|
|
title = re.sub(r' - [t|T]emp\w+.*?\d+', '', title)
|
|
title = re.sub(r' [t|T]emp.*?\d+x\d+', '', title)
|
|
title = re.sub(r' [t|T]emp.*?\d+', '', title)
|
|
title = re.sub(r' [c|C]ap.*?\d+', '', title)
|
|
if "audio" in title.lower(): #Reservamos info de audio para después de TMDB
|
|
title_subs += ['[%s]' % scrapertools.find_single_match(title, r'(\[[a|A]udio.*?\])')]
|
|
title = re.sub(r'\[[a|A]udio.*?\]', '', title)
|
|
if "[dual" in title.lower() or "multileng" in title.lower() or "multileng" in item_local.quality.lower() or (("espa" in title.lower() or "spani" in title.lower()) and "VOS" in item_local.language):
|
|
item_local.language[0:0] = ["DUAL"]
|
|
title = re.sub(r'\[[D|d]ual.*?\]', '', title)
|
|
title = re.sub(r'\[[M|m]ultileng.*?\]', '', title)
|
|
item_local.quality = re.sub(r'\[[M|m]ultileng.*?\]', '', item_local.quality)
|
|
if "duolog" in title.lower():
|
|
title_subs += ["[Saga]"]
|
|
title = title.replace(" Duologia", "").replace(" duologia", "").replace(" Duolog", "").replace(" duolog", "")
|
|
if "trilog" in title.lower():
|
|
title_subs += ["[Saga]"]
|
|
title = title.replace(" Trilogia", "").replace(" trilogia", "").replace(" Trilog", "").replace(" trilog", "")
|
|
if "extendida" in title.lower():
|
|
title_subs += ["[V. Extendida]"]
|
|
title = title.replace(" Version Extendida", "").replace(" (Version Extendida)", "").replace(" V. Extendida", "").replace(" VExtendida", "").replace(" V Extendida", "")
|
|
if "saga" in title.lower():
|
|
title = title.replace(" Saga Completa", "").replace(" saga sompleta", "").replace(" Saga", "").replace(" saga", "")
|
|
title_subs += ["[Saga]"]
|
|
if "colecc" in title.lower() or "completa" in title.lower():
|
|
title = title.replace(" Coleccion", "").replace(" coleccion", "").replace(" Colecci", "").replace(" colecci", "").replace(" Completa", "").replace(" completa", "").replace(" COMPLETA", "")
|
|
if scrapertools.find_single_match(title, r'(- [m|M].*?serie ?\w+)'):
|
|
title = re.sub(r'- [m|M].*?serie ?\w+', '', title)
|
|
title_subs += ["[Miniserie]"]
|
|
|
|
#Limpiamos restos en título
|
|
title = title.replace("Castellano", "").replace("castellano", "").replace("inglés", "").replace("ingles", "").replace("Inglés", "").replace("Ingles", "").replace("Espa", "").replace("Ingl", "").replace("Engl", "").replace("Calidad", "").replace("de la Serie", "")
|
|
title_alt = title_alt.replace("Castellano", "").replace("castellano", "").replace("inglés", "").replace("ingles", "").replace("Inglés", "").replace("Ingles", "").replace("Espa", "").replace("Ingl", "").replace("Engl", "").replace("Calidad", "").replace("de la Serie", "")
|
|
|
|
#Limpiamos cabeceras y colas del título
|
|
title = re.sub(r'Descargar\s\w+\-\w+', '', title)
|
|
title = re.sub(r'\(COMPLE.*?\)', '', title)
|
|
title = re.sub(r'\(\d{4}\)$', '', title)
|
|
title = re.sub(r'\d{4}$', '', title)
|
|
title = re.sub(r' \d+x\d+', '', title)
|
|
title = re.sub(r' x\d+', '', title)
|
|
|
|
title = title.replace("Ver online ", "").replace("Descarga Serie HD ", "").replace("Descargar Serie HD ", "").replace("Descarga Serie ", "").replace("Descargar Serie ", "").replace("Ver en linea ", "").replace("Ver en linea", "").replace("HD ", "").replace("(Proper)", "").replace("RatDVD", "").replace("DVDRiP", "").replace("DVDRIP", "").replace("DVDR", "").replace("DVD9", "").replace("DVD", "").replace("DVB", "").replace("- ES ", "").replace("ES ", "").replace("COMPLETA", "").replace("(", "-").replace(")", "-").replace(".", " ").strip()
|
|
|
|
title = title.replace("Descargar torrent ", "").replace("Descarga Gratis ", "").replace("Descargar Estreno ", "").replace("Descargar Estrenos ", "").replace("Pelicula en latino ", "").replace("Descargar Pelicula ", "").replace("Descargar Peliculas ", "").replace("Descargar peliculas ", "").replace("Descargar Todas ", "").replace("Descargar Otras ", "").replace("Descargar ", "").replace("Descarga ", "").replace("Bajar ", "").replace("HDRIP ", "").replace("HDRiP ", "").replace("HDRip ", "").replace("RIP ", "").replace("Rip", "").replace("RiP", "").replace("XviD", "").replace("AC3 5.1", "").replace("AC3", "").replace("1080p ", "").replace("720p ", "").replace("DVD-Screener ", "").replace("TS-Screener ", "").replace("Screener ", "").replace("BdRemux ", "").replace("BR ", "").replace("4KULTRA", "").replace("FULLBluRay", "").replace("FullBluRay", "").replace("BluRay", "").replace("Bonus Disc", "").replace("de Cine ", "").replace("TeleCine ", "").replace("latino", "").replace("Latino", "").replace("argentina", "").replace("Argentina", "").strip()
|
|
|
|
if title.endswith("torrent gratis"): title = title[:-15]
|
|
if title.endswith("gratis"): title = title[:-7]
|
|
if title.endswith("torrent"): title = title[:-8]
|
|
if title.endswith("en HD"): title = title[:-6]
|
|
if title.endswith(" -"): title = title[:-2]
|
|
if "en espa" in title: title = title[:-11]
|
|
|
|
item_local.quality = item_local.quality.replace("gratis ", "")
|
|
if "HDR" in title:
|
|
title = title.replace(" HDR", "")
|
|
if not "HDR" in item_local.quality:
|
|
item_local.quality += " HDR"
|
|
|
|
title = title.strip()
|
|
title_alt = title_alt.strip()
|
|
item_local.quality = item_local.quality.strip()
|
|
|
|
if not title: #Usamos solo el title_alt en caso de que no exista el título original
|
|
title = title_alt
|
|
if not title:
|
|
title = "SIN TITULO"
|
|
|
|
#Limpieza final del título y guardado en las variables según su tipo de contenido
|
|
title = scrapertools.remove_htmltags(title)
|
|
item_local.title = title
|
|
if item_local.contentType == "movie":
|
|
item_local.contentTitle = title
|
|
else:
|
|
item_local.contentSerieName = title
|
|
|
|
#Guardamos el resto de variables del vídeo
|
|
item_local.url = scrapedurl
|
|
item_local.thumbnail = scrapedthumbnail
|
|
item_local.contentThumbnail = scrapedthumbnail
|
|
|
|
#Guardamos el año que puede venir en la url, por si luego no hay resultados desde TMDB
|
|
year = ''
|
|
if item_local.contentType == "movie":
|
|
year = scrapertools.find_single_match(scrapedurl, r'(\d{4})')
|
|
if year >= "1900" and year <= "2040" and year != "2020":
|
|
title_subs += [year]
|
|
item_local.infoLabels['year'] = '-'
|
|
|
|
#Guarda la variable temporal que almacena la info adicional del título a ser restaurada después de TMDB
|
|
item_local.title_subs = title_subs
|
|
|
|
#Agrega el item local a la lista itemlist
|
|
itemlist.append(item_local.clone())
|
|
|
|
#Pasamos a TMDB la lista completa Itemlist
|
|
tmdb.set_infoLabels(itemlist, True)
|
|
|
|
# Pasada para maquillaje de los títulos obtenidos desde TMDB
|
|
for item_local in itemlist:
|
|
title = item_local.title
|
|
|
|
#Restauramos la info adicional guarda en la lista title_subs, y la borramos de Item
|
|
if len(item_local.title_subs) > 0:
|
|
title += " "
|
|
for title_subs in item_local.title_subs:
|
|
if "audio" in title_subs.lower():
|
|
title = '%s [%s]' % (title, scrapertools.find_single_match(title_subs, r'[a|A]udio (.*?)'))
|
|
continue
|
|
if scrapertools.find_single_match(title_subs, r'(\d{4})'):
|
|
if not item_local.infoLabels['year'] or item_local.infoLabels['year'] == "-":
|
|
item_local.infoLabels['year'] = scrapertools.find_single_match(title_subs, r'(\d{4})')
|
|
continue
|
|
if not config.get_setting("unify"): #Si Titulos Inteligentes NO seleccionados:
|
|
title = '%s %s' % (title, title_subs)
|
|
else:
|
|
title = '%s -%s-' % (title, title_subs)
|
|
del item_local.title_subs
|
|
|
|
# Si TMDB no ha encontrado el vídeo limpiamos el año
|
|
if item_local.infoLabels['year'] == "-":
|
|
item_local.infoLabels['year'] = ''
|
|
item_local.infoLabels['aired'] = ''
|
|
|
|
# Preparamos el título para series, con los núm. de temporadas, si las hay
|
|
if item_local.contentType == "season" or item_local.contentType == "tvshow":
|
|
item_local.contentTitle= ''
|
|
|
|
rating = ''
|
|
if item_local.infoLabels['rating'] and item_local.infoLabels['rating'] != '0.0':
|
|
rating = float(item_local.infoLabels['rating'])
|
|
rating = round(rating, 1)
|
|
|
|
#Ahora maquillamos un poco los titulos dependiendo de si se han seleccionado títulos inteleigentes o no
|
|
if not config.get_setting("unify"): #Si Titulos Inteligentes NO seleccionados:
|
|
if item_local.contentType == "season" or item_local.contentType == "tvshow":
|
|
title = '%s [COLOR yellow][%s][/COLOR] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (title, scrapertools.find_single_match(str(item_local.infoLabels['aired']), r'\/(\d{4})'), rating, item_local.quality, str(item_local.language))
|
|
|
|
elif item_local.contentType == "movie":
|
|
title = '%s [COLOR yellow][%s][/COLOR] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (title, str(item_local.infoLabels['year']), rating, item_local.quality, str(item_local.language))
|
|
|
|
if config.get_setting("unify"): #Si Titulos Inteligentes SÍ seleccionados:
|
|
title = title.replace("[", "-").replace("]", "-")
|
|
|
|
title = title.replace("--", "").replace(" []", "").replace("()", "").replace("(/)", "").replace("[/]", "").strip()
|
|
title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', title).strip()
|
|
title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', title).strip()
|
|
|
|
if category == "newest": #Viene de Novedades. Marquemos el título con el nombre del canal
|
|
title += ' -%s-' % item_local.channel.capitalize()
|
|
if item_local.contentType == "movie":
|
|
item_local.contentTitle += ' -%s-' % item_local.channel.capitalize()
|
|
|
|
item_local.title = title
|
|
|
|
logger.debug("url: " + item_local.url + " / title: " + item_local.title + " / content title: " + item_local.contentTitle + "/" + item_local.contentSerieName + " / calidad: " + item_local.quality + " / year: " + str(item_local.infoLabels['year']))
|
|
#logger.debug(item_local)
|
|
|
|
if len(itemlist) == 0:
|
|
itemlist.append(Item(channel=item.channel, action="mainlist", title="No se ha podido cargar el listado"))
|
|
else:
|
|
if url_next_page:
|
|
itemlist.append(
|
|
Item(channel=item.channel, action="listado", title="[COLOR gold][B]Pagina siguiente >> [/B][/COLOR]" + str(post_num) + " de " + str(total_pag), url=url_next_page, next_page=next_page, cnt_pag=cnt_pag, post_num=post_num, pag=pag, modo=modo, extra=item.extra))
|
|
|
|
#logger.debug(url_next_page + " / " + next_page + " / " + str(matches_cnt) + " / " + str(cnt_pag)+ " / " + str(total_pag) + " / " + str(pag) + " / " + modo + " / " + item.extra)
|
|
|
|
return itemlist
|
|
|
|
def listado_busqueda(item):
|
|
logger.info()
|
|
itemlist = []
|
|
cnt_tot = 40 # Poner el num. máximo de items por página. Dejamos que la web lo controle
|
|
cnt_title = 0 # Contador de líneas insertadas en Itemlist
|
|
cnt_pag = 0 # Contador de líneas leídas de Matches
|
|
|
|
if item.cnt_pag:
|
|
cnt_pag = item.cnt_pag # Se guarda en la lista de páginas anteriores en Item
|
|
del item.cnt_pag
|
|
if item.totalItems:
|
|
del item.totalItems
|
|
if item.text_bold:
|
|
del item.text_bold
|
|
if item.text_color:
|
|
del item.text_color
|
|
|
|
#Sistema de paginado para evitar páginas vacías o semi-vacías en casos de búsquedas con series con muchos episodios
|
|
title_lista = [] # Guarda la lista de series que ya están en Itemlist, para no duplicar lineas
|
|
if item.title_lista: # Si viene de una pasada anterior, la lista ya estará guardada
|
|
title_lista = item.title_lista # Se usa la lista de páginas anteriores en Item
|
|
title_lista_alt = []
|
|
for url in title_lista:
|
|
title_lista_alt += [url] #hacemos una copia no vinculada de title_lista
|
|
matches = []
|
|
cnt_next = 0
|
|
total_pag = 1
|
|
post_num = 1
|
|
|
|
#Máximo num. de líneas permitidas por TMDB. Máx de 5 páginas por Itemlist para no degradar el rendimiento
|
|
while cnt_title <= cnt_tot and cnt_next < 5:
|
|
|
|
data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(item.url, post=item.post).data)
|
|
cnt_next += 1
|
|
if not data: #Si la web está caída salimos sin dar error
|
|
return itemlist
|
|
|
|
#Obtiene la dirección de la próxima página, si la hay
|
|
try:
|
|
post_actual = item.post #Guardamos el post actual por si hay overflow de Itemlist y hay que hechar marcha atrás
|
|
get, post, total_pag = scrapertools.find_single_match(data, '<ul class="pagination">.*?<a\s*href="([^"]+)"(?:\s*onClick=".*?\(\'([^"]+)\'\);">Next<\/a>.*?onClick=".*?\(\'([^"]+)\'\);">Last<\/a>)')
|
|
except:
|
|
post = False
|
|
cnt_next = 99 #No hay más páginas. Salir del bucle después de procesar ésta
|
|
|
|
if post: #puntero a la siguiente página. Cada página de la web tiene 30 entradas
|
|
if "pg" in item.post:
|
|
item.post = re.sub(r"pg=(\d+)", "pg=%s" % post, item.post)
|
|
else:
|
|
item.post += "&pg=%s" % post
|
|
post_num = int(post)-1 #Guardo página actual
|
|
|
|
# Preparamos un patron que pretence recoger todos los datos significativos del video
|
|
pattern = '<ul class="%s">(.*?)</ul>' % item.pattern #seleccionamos en bloque que nos interesa
|
|
data = scrapertools.get_match(data, pattern)
|
|
#pattern = '<li[^>]*><a href="(?P<url>[^"]+).*?<img.*?src="(?P<thumb>[^"]+)?".*?<h2.*?>(?P<title>.*?)?<\/h2>'
|
|
pattern = '<li[^>]*><a href="(?P<scrapedurl>[^"]+).*?' #url
|
|
pattern += 'title="(?P<scrapedtitle>[^"]+).*?' #título
|
|
pattern += '<img.*?src="(?P<scrapedthumbnail>[^"]+)?".*?' #thumb
|
|
pattern += '<h2.*?(?P<calidad>\[.*?)?<\/h2.*?' #calidad
|
|
pattern += '<span.*?>\d+-\d+-(?P<year>\d{4})?<\/span>*.?' #año
|
|
pattern += '<span.*?>(?P<size>\d+[\.|\s].*?[GB|MB])?<\/span>' #tamaño (significativo para peliculas)
|
|
matches_alt = re.compile(pattern, re.DOTALL).findall(data)
|
|
|
|
#Ahora se hace una simulación para saber cuantas líneas podemos albergar en este Itemlist.
|
|
#Se controlará cuantas páginas web se tienen que leer para rellenar la lista, sin pasarse
|
|
for scrapedurl, scrapedtitle, scrapedthumbnail, calidad, year, size in matches_alt:
|
|
|
|
#Realiza un control de las series que se añaden, ya que el buscador devuelve episodios y no las series completas
|
|
#Se analiza si la url de la serie ya se ha listado antes. Si es así, esa entrada se ignora
|
|
#Cuando llega al num. máximo de entradas por página, la pinta y guarda los contadores y la lista de series
|
|
if "pelisyseries.com" in host: #Excepción para mispelisyseries.com.
|
|
scrapedurl_alt = scrapedurl
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-\d+-al-\d+', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-\d+', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/\d{5,7}', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
if scrapedurl_alt in title_lista_alt: # si ya se ha tratado, pasamos al siguiente item
|
|
continue # solo guardamos la url para series y docus
|
|
|
|
if scrapedurl in title_lista_alt: # si ya se ha tratado, pasamos al siguiente item
|
|
continue # solo guardamos la url para series y docus
|
|
|
|
if ".com/serie" in scrapedurl or "/serie" in scrapedurl or "-serie" in scrapedurl or "varios/" in scrapedurl:
|
|
if "pelisyseries.com" in host:
|
|
title_lista_alt += [scrapedurl_alt]
|
|
else:
|
|
title_lista_alt += [scrapedurl]
|
|
if "juego/" in scrapedurl: # no mostramos lo que no sean videos
|
|
continue
|
|
cnt_title += 1 # Sería una línea real más para Itemlist
|
|
|
|
#Control de página
|
|
if cnt_title > cnt_tot*0.65: #si se acerca al máximo num. de lineas por pagina, tratamos lo que tenemos
|
|
cnt_next = 99 #Casi completo, no sobrepasar con la siguiente página
|
|
if cnt_title > cnt_tot:
|
|
cnt_title = 99 #Sobrepasado el máximo. Ignoro página actual
|
|
item.post = post_actual #Restauro puntero "next" a la página actual, para releearla en otra pasada
|
|
post_num -= 1 #Restauro puntero a la página actual en el pie de página
|
|
break
|
|
|
|
if cnt_title <= cnt_tot:
|
|
matches.extend(matches_alt) #Acumulamos las entradas a tratar. Si nos hemos pasado ignoro última página
|
|
|
|
#logger.debug("PATRON: " + pattern)
|
|
#logger.debug(matches)
|
|
#logger.debug(data)
|
|
|
|
cnt_title = 0
|
|
for scrapedurl, scrapedtitle, scrapedthumbnail, calidad, year, size in matches:
|
|
cnt_pag += 1
|
|
|
|
#Realiza un control de las series que se añaden, ya que el buscador devuelve episodios y no las series completas
|
|
#Se analiza si la url de la serie ya se ha listado antes. Si es así, esa entrada se ignora
|
|
#El control de página ya se ha realizado más arriba
|
|
if "pelisyseries.com" in host: #Excepción para mispelisyseries.com.
|
|
scrapedurl_alt = scrapedurl
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-\d+-al-\d+', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-\d+', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/[c|C]ap.*?-', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
scrapedurl_alt = re.sub(r'\/\d{5,7}', '', scrapedurl_alt) #Scrapeo el capítulo para hacerlo serie
|
|
if scrapedurl_alt in title_lista: # si ya se ha tratado, pasamos al siguiente item
|
|
continue # solo guardamos la url para series y docus
|
|
|
|
if scrapedurl in title_lista: # si ya se ha tratado, pasamos al siguiente item
|
|
continue # solo guardamos la url para series y docus
|
|
|
|
if ".com/serie" in scrapedurl or "/serie" in scrapedurl or "-serie" in scrapedurl or "varios/" in scrapedurl:
|
|
if "pelisyseries.com" in host:
|
|
title_lista += [scrapedurl_alt]
|
|
else:
|
|
title_lista += [scrapedurl]
|
|
if "juego/" in scrapedurl or "xbox" in scrapedurl.lower() or "xbox" in scrapedtitle.lower() or "windows" in scrapedtitle.lower() or "windows" in calidad.lower() or "nintendo" in scrapedtitle.lower() or "xbox" in calidad.lower() or "epub" in calidad.lower() or "pdf" in calidad.lower() or "pcdvd" in calidad.lower() or "crack" in calidad.lower(): # no mostramos lo que no sean videos
|
|
continue
|
|
cnt_title += 1 # Sería una línea real más para Itemlist
|
|
|
|
#Creamos una copia de Item para cada contenido
|
|
item_local = item.clone()
|
|
if item_local.category:
|
|
del item_local.category
|
|
if item_local.tipo:
|
|
del item_local.tipo
|
|
if item_local.totalItems:
|
|
del item_local.totalItems
|
|
if item_local.post:
|
|
del item_local.post
|
|
if item_local.pattern:
|
|
del item_local.pattern
|
|
if item_local.title_lista:
|
|
del item_local.title_lista
|
|
item_local.adult = True
|
|
del item_local.adult
|
|
item_local.folder = True
|
|
del item_local.folder
|
|
item_local.title = ''
|
|
item_local.context = "['buscar_trailer']"
|
|
|
|
#Establecemos los valores básicos en función del tipo de contenido
|
|
if (".com/serie" in scrapedurl or "/serie" in scrapedurl or "-serie" in scrapedurl) and not "/miniseries" in scrapedurl: #Series
|
|
item_local.action = "episodios"
|
|
item_local.contentType = "tvshow"
|
|
item_local.extra = "series"
|
|
elif "varios/" in scrapedurl or "/miniseries" in scrapedurl: #Documentales y varios
|
|
item_local.action = "findvideos"
|
|
item_local.contentType = "movie"
|
|
item_local.extra = "varios"
|
|
else: #Películas
|
|
item_local.action = "findvideos"
|
|
item_local.contentType = "movie"
|
|
item_local.extra = "peliculas"
|
|
|
|
# Limpiamos títulos, Sacamos datos de calidad, audio y lenguaje
|
|
title = re.sub('\r\n', '', scrapedtitle).decode('iso-8859-1').encode('utf8').strip()
|
|
title = title.replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o").replace("ú", "u").replace("ü", "u").replace("�", "ñ").replace("ñ", "ñ")
|
|
|
|
item_local.quality = scrapertools.htmlclean(calidad)
|
|
title_subs = []
|
|
|
|
#Determinamos y marcamos idiomas distintos del castellano
|
|
item_local.language = []
|
|
if "[vos" in title.lower() or "v.o.s" in title.lower() or "vo" in title.lower() or ".com/pelicula/" in scrapedurl or ".com/series-vo" in scrapedurl or "-vo/" in scrapedurl or "vos" in calidad.lower() or "vose" in calidad.lower() or "v.o.s" in calidad.lower() or "sub" in calidad.lower() or ".com/peliculas-vo" in item.url:
|
|
item_local.language += ["VOS"]
|
|
title = title.replace(" [Subs. integrados]", "").replace(" [subs. Integrados]", "").replace(" [VOSE", "").replace(" [VOS", "").replace(" (V.O.S.E)", "").replace(" VO", "").replace("Subtitulos", "")
|
|
if "latino" in title.lower() or "argentina" in title.lower() or "-latino/" in scrapedurl or "latino" in calidad.lower() or "argentina" in calidad.lower():
|
|
item_local.language += ["LAT"]
|
|
|
|
#Guardamos info de 3D en calidad y limpiamos
|
|
if "3d" in title.lower():
|
|
if not "3d" in item_local.quality.lower():
|
|
item_local.quality = "3D " + item_local.quality
|
|
calidad3D = scrapertools.find_single_match(title, r'\s(3[d|D]\s\w+)')
|
|
if calidad3D:
|
|
item_local.quality = item_local.quality.replace("3D", calidad3D)
|
|
title = re.sub(r'\s3[d|D]\s\w+', '', title)
|
|
title = re.sub(r'\s3[d|D]', '', title)
|
|
if "imax" in title.lower():
|
|
item_local.quality = item_local.quality + " IMAX"
|
|
title = title.replace(" IMAX", "").replace(" imax", "")
|
|
if "2d" in title.lower():
|
|
title = title.replace("(2D)", "").replace("(2d)", "").replace("2D", "").replace("2d", "")
|
|
title_subs += ["[2D]"]
|
|
|
|
#Extraemos info adicional del título y la guardamos para después de TMDB
|
|
if ("temp" in title.lower() or "cap" in title.lower()) and item_local.contentType != "movie":
|
|
#Eliminamos Temporada de Series, solo nos interesa la serie completa
|
|
title = re.sub(r' - [t|T]emp\w+ \d+[x|X]\d+', '', title)
|
|
title = re.sub(r' - [t|T]emp\w+ \d+', '', title)
|
|
title = re.sub(r' - [t|T]emp\w+.*?\d+', '', title)
|
|
title = re.sub(r' [t|T]emp.*?\d+[x|X]\d+', '', title)
|
|
title = re.sub(r' [t|T]emp.*?\d+', '', title)
|
|
title = re.sub(r' [c|C]ap.*?\d+', '', title)
|
|
if "audio" in title.lower(): #Reservamos info de audio para después de TMDB
|
|
title_subs += ['[%s]' % scrapertools.find_single_match(title, r'(\[[a|A]udio.*?\])')]
|
|
title = re.sub(r'\[[a|A]udio.*?\]', '', title)
|
|
if "[dual" in title.lower() or "multileng" in title.lower() or "multileng" in item_local.quality.lower() or (("espa" in title.lower() or "spani" in title.lower()) and "VOS" in item_local.language):
|
|
item_local.language[0:0] = ["DUAL"]
|
|
title = re.sub(r'\[[D|d]ual.*?\]', '', title)
|
|
title = re.sub(r'\[[M|m]ultileng.*?\]', '', title)
|
|
item_local.quality = re.sub(r'\[[M|m]ultileng.*?\]', '', item_local.quality)
|
|
if "duolog" in title.lower():
|
|
title_subs += ["[Saga]"]
|
|
title = title.replace(" Duologia", "").replace(" duologia", "").replace(" Duolog", "").replace(" duolog", "")
|
|
if "trilog" in title.lower():
|
|
title_subs += ["[Saga]"]
|
|
title = title.replace(" Trilogia", "").replace(" trilogia", "").replace(" Trilog", "").replace(" trilog", "")
|
|
if "extendida" in title.lower():
|
|
title_subs += ["[V. Extendida]"]
|
|
title = title.replace(" Version Extendida", "").replace(" (Version Extendida)", "").replace(" V. Extendida", "").replace(" VExtendida", "").replace(" V Extendida", "")
|
|
if "saga" in title.lower():
|
|
title = title.replace(" Saga Completa", "").replace(" saga completa", "").replace(" Saga", "").replace(" saga", "")
|
|
title_subs += ["[Saga]"]
|
|
if "colecc" in title.lower() or "completa" in title.lower():
|
|
title = title.replace(" Coleccion", "").replace(" coleccion", "").replace(" Colecci", "").replace(" colecci", "").replace(" Completa", "").replace(" completa", "").replace(" COMPLETA", "")
|
|
title_subs += ["[Saga]"]
|
|
if scrapertools.find_single_match(title, r'(- [m|M].*?serie ?\w+)'):
|
|
title = re.sub(r'- [m|M].*?serie ?\w+', '', title)
|
|
title_subs += ["[Miniserie]"]
|
|
|
|
#Limpiamos restos en título
|
|
title = title.replace("Castellano", "").replace("castellano", "").replace("inglés", "").replace("ingles", "").replace("Inglés", "").replace("Ingles", "").replace("Esp", "").replace("Ing", "").replace("Eng", "").replace("Calidad", "").replace("de la Serie", "")
|
|
|
|
#Limpiamos cabeceras y colas del título
|
|
title = re.sub(r'Descargar\s\w+\-\w+', '', title)
|
|
title = re.sub(r'\(COMPLE.*?\)', '', title)
|
|
title = re.sub(r'\(\d{4}\)$', '', title)
|
|
title = re.sub(r'\d{4}$', '', title)
|
|
title = re.sub(r' \d+x\d+', '', title)
|
|
title = re.sub(r' x\d+', '', title)
|
|
|
|
title = title.replace("Ver online ", "").replace("Descarga Serie HD ", "").replace("Descargar Serie HD ", "").replace("Descarga Serie ", "").replace("Descargar Serie ", "").replace("Ver en linea ", "").replace("Ver en linea", "").replace("HD ", "").replace("(Proper)", "").replace("RatDVD", "").replace("DVDRiP", "").replace("DVDRIP", "").replace("DVDR", "").replace("DVD9", "").replace("DVD", "").replace("DVB", "").replace("- ES ", "").replace("ES ", "").replace("COMPLETA", "").replace("(", "-").replace(")", "-").replace(".", " ").strip()
|
|
|
|
title = title.replace("Descargar torrent ", "").replace("Descarga Gratis ", "").replace("Descargar Estreno ", "").replace("Descargar Estrenos ", "").replace("Pelicula en latino ", "").replace("Descargar Pelicula ", "").replace("Descargar Peliculas ", "").replace("Descargar peliculas ", "").replace("Descargar Todas ", "").replace("Descargar Otras ", "").replace("Descargar ", "").replace("Descarga ", "").replace("Bajar ", "").replace("HDRIP ", "").replace("HDRiP ", "").replace("HDRip ", "").replace("RIP ", "").replace("Rip", "").replace("RiP", "").replace("XviD", "").replace("AC3 5.1", "").replace("AC3", "").replace("1080p ", "").replace("720p ", "").replace("DVD-Screener ", "").replace("TS-Screener ", "").replace("Screener ", "").replace("BdRemux ", "").replace("BR ", "").replace("4KULTRA", "").replace("FULLBluRay", "").replace("FullBluRay", "").replace("BluRay", "").replace("Bonus Disc", "").replace("de Cine ", "").replace("TeleCine ", "").replace("latino", "").replace("Latino", "").replace("argentina", "").replace("Argentina", "").strip()
|
|
|
|
if "pelisyseries.com" in host and item_local.contentType == "tvshow":
|
|
titulo = ''
|
|
title = title.lower()
|
|
title = re.sub(r'\d+[x|X]\d+', '', title)
|
|
while len(title) > 0:
|
|
palabra = scrapertools.find_single_match(title, r'(^[A-Za-z0-9_.-?ñ]+)')
|
|
if not palabra:
|
|
break
|
|
title = title.replace(palabra, '')
|
|
title = re.sub(r'^\s+\??', '', title)
|
|
title = re.sub(r'^-\s?', '', title)
|
|
titulo += palabra + " "
|
|
palabra = ""
|
|
title = titulo.title()
|
|
|
|
if title.endswith("torrent gratis"): title = title[:-15]
|
|
if title.endswith("gratis"): title = title[:-7]
|
|
if title.endswith("torrent"): title = title[:-8]
|
|
if title.endswith("en HD"): title = title[:-6]
|
|
if title.endswith(" -"): title = title[:-2]
|
|
if "en espa" in title: title = title[:-11]
|
|
#title = re.sub(r'^\s', '', title)
|
|
title = title.replace("a?o", 'año').replace("a?O", 'año').replace("A?o", 'Año').replace("A?O", 'Año').strip()
|
|
|
|
#Preparamos calidad
|
|
item_local.quality = item_local.quality.replace("[ ", "").replace(" ]", "") #Preparamos calidad para Series
|
|
item_local.quality = re.sub(r'\[\d{4}\]', '', item_local.quality) #Quitar año, si lo tiene
|
|
item_local.quality = re.sub(r'\[Cap.*?\]', '', item_local.quality) #Quitar episodios, si lo tiene
|
|
item_local.quality = re.sub(r'\[Docu.*?\]', '', item_local.quality) #Quitar tipo contenidos, si lo tiene
|
|
#Mirar si es DUAL
|
|
if "VOS" in item_local.language and "DUAL" not in item_local.language and ("[sp" in item_local.quality.lower() or "espa" in item_local.quality.lower() or "cast" in item_local.quality.lower() or "spani" in item_local.quality.lower()):
|
|
item_local.language[0:0] = ["DUAL"]
|
|
if ("[es-" in item_local.quality.lower() or (("cast" in item_local.quality.lower() or "espa" in item_local.quality.lower() or "spani" in item_local.quality.lower()) and ("eng" in item_local.quality.lower() or "ing" in item_local.quality.lower()))) and "DUAL" not in item_local.language: #Mirar si es DUAL
|
|
item_local.language[0:0] = ["DUAL"] #Salvar DUAL en idioma
|
|
item_local.quality = re.sub(r'\[[es|ES]-\w+]', '', item_local.quality) #borrar DUAL
|
|
item_local.quality = re.sub(r'[\s|-][c|C]aste.+', '', item_local.quality) #Borrar después de Castellano
|
|
item_local.quality = re.sub(r'[\s|-][e|E]spa.+', '', item_local.quality) #Borrar después de Español
|
|
item_local.quality = re.sub(r'[\s|-|\[][s|S]pani.+', '', item_local.quality) #Borrar después de Spanish
|
|
item_local.quality = re.sub(r'[\s|-][i|I|e|E]ngl.+', '', item_local.quality) #Borrar después de Inglés-English
|
|
item_local.quality = item_local.quality.replace("[", "").replace("]", " ").replace("ALTA DEFINICION", "HDTV").replace(" Cap", "")
|
|
#Borrar palabras innecesarias restantes
|
|
item_local.quality = item_local.quality.replace("Espaol", "").replace("Español", "").replace("Espa", "").replace("Castellano ", "").replace("Castellano", "").replace("Spanish", "").replace("English", "").replace("Ingles", "").replace("Latino", "").replace("+Subs", "").replace("-Subs", "").replace("Subs", "").replace("VOSE", "").replace("VOS", "").strip()
|
|
|
|
#Limpieza final del título y guardado en las variables según su tipo de contenido
|
|
item_local.title = title
|
|
if item_local.contentType == "movie":
|
|
item_local.contentTitle = title
|
|
size = size.replace(".", ",")
|
|
item_local.quality = '%s [%s]' % (item_local.quality, size)
|
|
else:
|
|
item_local.contentSerieName = title
|
|
|
|
#Guardamos el resto de variables del vídeo
|
|
item_local.url = scrapedurl
|
|
item_local.thumbnail = scrapedthumbnail
|
|
item_local.contentThumbnail = scrapedthumbnail
|
|
|
|
#Guardamos el año que puede venir en la url, por si luego no hay resultados desde TMDB
|
|
if year >= "1900" and year <= "2040" and year != "2020":
|
|
title_subs += [year]
|
|
item_local.infoLabels['year'] = '-'
|
|
|
|
#Guarda la variable temporal que almacena la info adicional del título a ser restaurada después de TMDB
|
|
item_local.title_subs = title_subs
|
|
|
|
# Codigo para rescatar lo que se pueda en pelisy.series.com de Series para la Videoteca. la URL apunta al capítulo y no a la Serie. Nombre de Serie frecuentemente en blanco. Se obtiene de Thumb, así como el id de la serie
|
|
if ("/serie" in item_local.url or "-serie" in item_local.url) and "pelisyseries.com" in host:
|
|
#Extraer la calidad de la serie basados en la info de la url
|
|
if "seriehd" in url:
|
|
calidad_mps = "series-hd/"
|
|
elif "serievo" in url or "serie-vo" in url:
|
|
calidad_mps = "series-vo/"
|
|
else:
|
|
calidad_mps = "series/"
|
|
|
|
if "no_image" in scrapedthumbnail:
|
|
real_title_mps = item_local.title
|
|
else:
|
|
real_title_mps = re.sub(r'.*?\/\d+_', '', scrapedthumbnail)
|
|
real_title_mps = re.sub(r'\.\w+.*?', '', real_title_mps)
|
|
|
|
#Extraer el ID de la serie desde Thumbs (4 dígitos). Si no hay, nulo
|
|
if "/0_" not in scrapedthumbnail and not "no_image" in scrapedthumbnail:
|
|
serieid = scrapertools.find_single_match(scrapedthumbnail, r'.*?\/\w\/(?P<serieid>\d+).*?.*')
|
|
if len(serieid) > 5:
|
|
serieid = ""
|
|
else:
|
|
serieid = ""
|
|
|
|
#detectar si la url creada de tvshow es válida o hay que volver atras
|
|
url_id = host + calidad_mps + real_title_mps + "/" + serieid #A veces necesita el serieid...
|
|
url_tvshow = host + calidad_mps + real_title_mps + "/" #... otras no. A probar...
|
|
|
|
#Leemos la página, a ver si es una página de episodios
|
|
data_serie = data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(url_id).data)
|
|
data_serie = unicode(data_serie, "iso-8859-1", errors="replace").encode("utf-8")
|
|
data_serie = data_serie.replace("chapters", "buscar-list")
|
|
|
|
pattern = '<ul class="%s">(.*?)</ul>' % "buscar-list" #Patrón de lista de episodios
|
|
if not scrapertools.find_single_match(data_serie, pattern) and serieid: #no es válida la página,
|
|
#intentarlo con la otra url
|
|
data_serie = data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(url_tvshow).data)
|
|
data_serie = unicode(data_serie, "iso-8859-1", errors="replace").encode("utf-8")
|
|
data_serie = data_serie.replace("chapters", "buscar-list")
|
|
|
|
if not scrapertools.find_single_match(data_serie, pattern): #No ha habido suerte ...
|
|
item_local.contentType = "movie" #tratarlo el capítulo como película
|
|
item_local.extra = "peliculas"
|
|
else:
|
|
item_local.url = url_tvshow #Cambiamos url de episodio por el de serie
|
|
else:
|
|
item_local.url = url_id #Cambiamos url de episodio por el de serie
|
|
|
|
#logger.debug("url: " + item_local.url + " / title o/n: " + item_local.title + " / " + real_title_mps + " / calidad_mps : " + calidad_mps + " / contentType : " + item_local.contentType)
|
|
|
|
item_local.title = real_title_mps #Esperemos que el nuevo título esté bien
|
|
|
|
#Agrega el item local a la lista itemlist
|
|
itemlist.append(item_local.clone())
|
|
|
|
if not item.category: #Si este campo no existe es que viene de la primera pasada de una búsqueda global
|
|
return itemlist #Retornamos sin pasar por la fase de maquillaje para ahorra tiempo
|
|
|
|
#Pasamos a TMDB la lista completa Itemlist
|
|
tmdb.set_infoLabels(itemlist, True)
|
|
|
|
# Pasada para maquillaje de los títulos obtenidos desde TMDB
|
|
for item_local in itemlist:
|
|
title = item_local.title
|
|
|
|
#Restauramos la info adicional guarda en la lista title_subs, y la borramos de Item
|
|
if len(item_local.title_subs) > 0:
|
|
title += " "
|
|
for title_subs in item_local.title_subs:
|
|
if "audio" in title_subs.lower():
|
|
title = '%s [%s]' % (title, scrapertools.find_single_match(title_subs, r'[a|A]udio (.*?)'))
|
|
continue
|
|
if scrapertools.find_single_match(title_subs, r'(\d{4})'):
|
|
if not item_local.infoLabels['year'] or item_local.infoLabels['year'] == "-":
|
|
item_local.infoLabels['year'] = scrapertools.find_single_match(title_subs, r'(\d{4})')
|
|
continue
|
|
if not config.get_setting("unify"): #Si Titulos Inteligentes NO seleccionados:
|
|
title = '%s %s' % (title, title_subs)
|
|
else:
|
|
title = '%s -%s-' % (title, title_subs)
|
|
del item_local.title_subs
|
|
|
|
# Si TMDB no ha encontrado el vídeo limpiamos el año
|
|
if item_local.infoLabels['year'] == "-":
|
|
item_local.infoLabels['year'] = ''
|
|
item_local.infoLabels['aired'] = ''
|
|
|
|
# Preparamos el título para series, con los núm. de temporadas, si las hay
|
|
if item_local.contentType == "season" or item_local.contentType == "tvshow":
|
|
item_local.contentTitle= ''
|
|
title += " -Serie-"
|
|
elif item_local.extra == "varios":
|
|
title += " -Varios-"
|
|
item_local.contentTitle += " -Varios-"
|
|
|
|
rating = ''
|
|
if item_local.infoLabels['rating'] and item_local.infoLabels['rating'] != '0.0':
|
|
rating = float(item_local.infoLabels['rating'])
|
|
rating = round(rating, 1)
|
|
|
|
#Ahora maquillamos un poco los titulos dependiendo de si se han seleccionado títulos inteleigentes o no
|
|
if not config.get_setting("unify"): #Si Titulos Inteligentes NO seleccionados:
|
|
if item_local.contentType == "season" or item_local.contentType == "tvshow":
|
|
title = '%s [COLOR yellow][%s][/COLOR] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (title, scrapertools.find_single_match(str(item_local.infoLabels['aired']), r'\/(\d{4})'), rating, item_local.quality, str(item_local.language))
|
|
|
|
elif item_local.contentType == "movie":
|
|
title = '%s [COLOR yellow][%s][/COLOR] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (title, str(item_local.infoLabels['year']), rating, item_local.quality, str(item_local.language))
|
|
|
|
if config.get_setting("unify"): #Si Titulos Inteligentes SÍ seleccionados:
|
|
title = title.replace("[", "-").replace("]", "-")
|
|
|
|
title = title.replace("--", "").replace(" []", "").replace("()", "").replace("(/)", "").replace("[/]", "").strip()
|
|
title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', title).strip()
|
|
title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', title).strip()
|
|
item_local.title = title
|
|
|
|
logger.debug("url: " + item_local.url + " / title: " + item_local.title + " / content title: " + item_local.contentTitle + "/" + item_local.contentSerieName + " / calidad: " + item_local.quality + "[" + str(item_local.language) + "]" + " / year: " + str(item_local.infoLabels['year']))
|
|
|
|
#logger.debug(item_local)
|
|
|
|
if post:
|
|
itemlist.append(item.clone(channel=item.channel, action="listado_busqueda", title="[COLOR gold][B]Pagina siguiente >> [/B][/COLOR]" + str(post_num) + " de " + str(total_pag), thumbnail=get_thumb("next.png"), title_lista=title_lista, cnt_pag=cnt_pag))
|
|
|
|
#logger.debug("Titulos: " + str(len(itemlist)) + " Matches: " + str(len(matches)) + " Post: " + str(item.post) + " / " + str(post_actual) + " / " + str(total_pag))
|
|
|
|
return itemlist
|
|
|
|
def findvideos(item):
|
|
from core import channeltools
|
|
logger.info()
|
|
itemlist = []
|
|
|
|
# Cualquiera de las tres opciones son válidas
|
|
# item.url = item.url.replace(".com/",".com/ver-online/")
|
|
# item.url = item.url.replace(".com/",".com/descarga-directa/")
|
|
item.url = item.url.replace(".com/", ".com/descarga-torrent/")
|
|
|
|
#Función para limitar la verificación de enlaces de Servidores para Ver online y Descargas
|
|
try:
|
|
#Inicializamos las variables por si hay un error en medio del proceso
|
|
channel_exclude = []
|
|
ver_enlaces = []
|
|
ver_enlaces_veronline = -1 #Ver todos los enlaces Ver Online
|
|
verificar_enlaces_veronline = -1 #Verificar todos los enlaces Ver Online
|
|
verificar_enlaces_veronline_validos = True #"¿Contar sólo enlaces 'verificados' en Ver Online?"
|
|
excluir_enlaces_veronline = [] #Lista vacía de servidores excluidos en Ver Online
|
|
ver_enlaces_descargas = 0 #Ver todos los enlaces Descargar
|
|
verificar_enlaces_descargas = -1 #Verificar todos los enlaces Descargar
|
|
verificar_enlaces_descargas_validos = True #"¿Contar sólo enlaces 'verificados' en Descargar?"
|
|
excluir_enlaces_descargas = [] #Lista vacía de servidores excluidos en Descargar
|
|
|
|
#Leemos las opciones de permitir Servidores para Ver Online y Descargas
|
|
#Cargamos en .json del canal para ver las listas de valores en settings
|
|
channel_exclude = channeltools.get_channel_json(item.channel)
|
|
for settings in channel_exclude['settings']: #Se recorren todos los settings
|
|
if settings['id'] == "clonenewpct1_excluir1_enlaces_veronline": #lista de enlaces a excluir
|
|
max_excl = int(settings['max_excl']) #Máximo número de servidores excluidos
|
|
channel_exclude = settings['lvalues'] #Cargamos la lista de servidores
|
|
if settings['id'] == "clonenewpct1_ver_enlaces_descargas": #Número de enlances a ver o verificar
|
|
ver_enlaces = settings['lvalues'] #Cargamos la lista de num. de enlaces
|
|
|
|
#Primer loop para enlaces de Ver Online.
|
|
#Carga la variable de ver
|
|
ver_enlaces_veronline = int(config.get_setting("clonenewpct1_ver_enlaces_veronline", item.channel))
|
|
if ver_enlaces_veronline == 1: #a "Todos" le damos valor -1. Para "No" dejamos 0
|
|
ver_enlaces_veronline = -1
|
|
if ver_enlaces_veronline > 1: #para los demás valores, tomamos los de la lista
|
|
ver_enlaces_veronline = int(ver_enlaces[ver_enlaces_veronline])
|
|
|
|
#Carga la variable de verificar
|
|
verificar_enlaces_veronline = int(config.get_setting("clonenewpct1_verificar_enlaces_veronline", item.channel))
|
|
if verificar_enlaces_veronline == 1: #a "Todos" le damos valor -1. Para "No" dejamos 0
|
|
verificar_enlaces_veronline = -1
|
|
if verificar_enlaces_veronline > 1: #para los demás valores, tomamos los de la lista
|
|
verificar_enlaces_veronline = int(ver_enlaces[verificar_enlaces_veronline])
|
|
|
|
#Carga la variable de contar sólo los servidores verificados
|
|
verificar_enlaces_veronline_validos = int(config.get_setting("clonenewpct1_verificar_enlaces_veronline_validos", item.channel))
|
|
|
|
#Carga la variable de lista de servidores excluidos
|
|
x = 1
|
|
for x in range(1, max_excl+1): #recorremos todas las opciones de canales exluidos
|
|
valor = str(config.get_setting("clonenewpct1_excluir%s_enlaces_veronline" % x, item.channel))
|
|
valor = int(valor)
|
|
if valor > 0: #Evitamos "No"
|
|
excluir_enlaces_veronline += [channel_exclude[valor]] #Añadimos el nombre de servidor excluido a la lista
|
|
x += 1
|
|
|
|
#Segundo loop para enlaces de Descargar.
|
|
#Carga la variable de ver
|
|
ver_enlaces_descargas = int(config.get_setting("clonenewpct1_ver_enlaces_descargas", item.channel))
|
|
if ver_enlaces_descargas == 1: #a "Todos" le damos valor -1. Para "No" dejamos 0
|
|
ver_enlaces_descargas = -1
|
|
if ver_enlaces_descargas > 1: #para los demás valores, tomamos los de la lista
|
|
ver_enlaces_descargas = int(ver_enlaces[ver_enlaces_descargas])
|
|
|
|
#Carga la variable de verificar
|
|
verificar_enlaces_descargas = int(config.get_setting("clonenewpct1_verificar_enlaces_descargas", item.channel))
|
|
if verificar_enlaces_descargas == 1: #a "Todos" le damos valor -1. Para "No" dejamos 0
|
|
verificar_enlaces_descargas = -1
|
|
if verificar_enlaces_descargas > 1: #para los demás valores, tomamos los de la lista
|
|
verificar_enlaces_descargas = int(ver_enlaces[verificar_enlaces_descargas])
|
|
|
|
#Carga la variable de contar sólo los servidores verificados
|
|
verificar_enlaces_descargas_validos = int(config.get_setting("clonenewpct1_verificar_enlaces_descargas_validos", item.channel))
|
|
|
|
#Carga la variable de lista de servidores excluidos
|
|
x = 1
|
|
for x in range(1, max_excl+1): #recorremos todas las opciones de canales exluidos
|
|
valor = str(config.get_setting("clonenewpct1_excluir%s_enlaces_descargas" % x, item.channel))
|
|
valor = int(valor)
|
|
if valor > 0: #Evitamos "No"
|
|
excluir_enlaces_descargas += [channel_exclude[valor]] #Añadimos el nombre de servidor excluido a la lista
|
|
x += 1
|
|
|
|
except Exception, ex: #En caso de error, lo mostramos y reseteamos todas las variables
|
|
logger.error("Error en la lectura de parámentros del .json del canal: " + item.channel + " \n%s" % ex)
|
|
#Mostrar los errores
|
|
logger.debug(ver_enlaces_veronline)
|
|
logger.debug(verificar_enlaces_veronline)
|
|
logger.debug(verificar_enlaces_veronline_validos)
|
|
logger.debug(excluir_enlaces_veronline)
|
|
logger.debug(ver_enlaces_descargas)
|
|
logger.debug(verificar_enlaces_descargas)
|
|
logger.debug(verificar_enlaces_descargas_validos)
|
|
logger.debug(excluir_enlaces_descargas)
|
|
#Resetear las variables a sus valores por defecto
|
|
ver_enlaces_veronline = -1 #Ver todos los enlaces Ver Online
|
|
verificar_enlaces_veronline = -1 #Verificar todos los enlaces Ver Online
|
|
verificar_enlaces_veronline_validos = True #"¿Contar sólo enlaces 'verificados' en Ver Online?"
|
|
excluir_enlaces_veronline = [] #Lista vacía de servidores excluidos en Ver Online
|
|
ver_enlaces_descargas = 0 #Ver todos los enlaces Descargar
|
|
verificar_enlaces_descargas = -1 #Verificar todos los enlaces Descargar
|
|
verificar_enlaces_descargas_validos = True #"¿Contar sólo enlaces 'verificados' en Descargar?"
|
|
excluir_enlaces_descargas = [] #Lista vacía de servidores excluidos en Descargar
|
|
|
|
# Saber si estamos en una ventana emergente lanzada desde una viñeta del menú principal,
|
|
# con la función "play_from_library"
|
|
unify_status = False
|
|
try:
|
|
import xbmc
|
|
if xbmc.getCondVisibility('Window.IsMedia') == 1:
|
|
unify_status = config.get_setting("unify")
|
|
except:
|
|
unify_status = config.get_setting("unify")
|
|
|
|
#Salvamos la información de max num. de episodios por temporada para despues de TMDB
|
|
if item.infoLabels['temporada_num_episodios']:
|
|
num_episodios = item.infoLabels['temporada_num_episodios']
|
|
else:
|
|
num_episodios = 1
|
|
|
|
# Obtener la información actualizada del Episodio, si no la hay
|
|
if not item.infoLabels['tmdb_id'] or (not item.infoLabels['episodio_titulo'] and item.contentType == 'episode'):
|
|
tmdb.set_infoLabels(item, True)
|
|
elif (not item.infoLabels['tvdb_id'] and item.contentType == 'episode') or item.contentChannel == "videolibrary":
|
|
tmdb.set_infoLabels(item, True)
|
|
#Restauramos la información de max num. de episodios por temporada despues de TMDB
|
|
if item.infoLabels['temporada_num_episodios'] and num_episodios > item.infoLabels['temporada_num_episodios']:
|
|
item.infoLabels['temporada_num_episodios'] = num_episodios
|
|
|
|
# Descarga la página
|
|
data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
|
|
data = unicode(data, "iso-8859-1", errors="replace").encode("utf-8")
|
|
data = data.replace("$!", "#!").replace("'", "\"").replace("ñ", "ñ").replace("//pictures", "/pictures")
|
|
|
|
#Añadimos el tamaño para todos
|
|
size = scrapertools.find_single_match(data, '<div class="entry-left".*?><a href=".*?span class=.*?>Size:<\/strong>?\s(\d+?\.?\d*?\s\w[b|B])<\/span>')
|
|
size = size.replace(".", ",") #sustituimos . por , porque Unify lo borra
|
|
item.quality = re.sub('\s\[\d+,?\d*?\s\w[b|B]\]', '', item.quality) #Quitamos size de calidad, si lo traía
|
|
if size:
|
|
item.title = re.sub('\s\[\d+,?\d*?\s\w[b|B]\]', '', item.title) #Quitamos size de título, si lo traía
|
|
item.title = '%s [%s]' % (item.title, size) #Agregamos size al final del título
|
|
|
|
#Limpiamos de año y rating de episodios
|
|
if item.infoLabels['episodio_titulo']:
|
|
item.infoLabels['episodio_titulo'] = re.sub(r'\s?\[.*?\]', '', item.infoLabels['episodio_titulo'])
|
|
if item.infoLabels['episodio_titulo'] == item.contentSerieName:
|
|
item.infoLabels['episodio_titulo'] = ''
|
|
if item.infoLabels['aired'] and item.contentType == "episode":
|
|
item.infoLabels['year'] = scrapertools.find_single_match(str(item.infoLabels['aired']), r'\/(\d{4})')
|
|
|
|
#Generamos una copia de Item para trabajar sobre ella
|
|
item_local = item.clone()
|
|
|
|
# obtenemos la url torrent
|
|
patron = 'class="btn-torrent">.*?window.location.href = "(.*?)";'
|
|
item_local.url = scrapertools.find_single_match(data, patron)
|
|
item_local.url = item_local.url.replace(" ", "%20") #sustituimos espacios por %20, por si acaso
|
|
#logger.debug("Patron: " + patron + " url: " + item_local.url)
|
|
#logger.debug(data)
|
|
|
|
#Pintamos el pseudo-título con toda la información disponible del vídeo
|
|
item_local.action = ""
|
|
item_local.server = "torrent"
|
|
|
|
rating = '' #Ponemos el rating
|
|
if item_local.infoLabels['rating'] and item_local.infoLabels['rating'] != '0.0':
|
|
rating = float(item_local.infoLabels['rating'])
|
|
rating = round(rating, 1)
|
|
|
|
if item_local.contentType == "episode":
|
|
title = '%sx%s' % (str(item_local.contentSeason), str(item_local.contentEpisodeNumber).zfill(2))
|
|
if item_local.infoLabels['temporada_num_episodios']:
|
|
title = '%s (de %s)' % (title, str(item_local.infoLabels['temporada_num_episodios']))
|
|
title = '%s %s' % (title, item_local.infoLabels['episodio_titulo'])
|
|
title_gen = '%s, %s [COLOR yellow][%s][/COLOR] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR] [%s]' % (title, item_local.contentSerieName, item_local.infoLabels['year'], rating, item_local.quality, str(item_local.language), size)
|
|
else:
|
|
title = item_local.title
|
|
title_gen = title
|
|
|
|
title_gen = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', title_gen).strip() #Quitamos etiquetas vacías
|
|
title_gen = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', title_gen).strip() #Quitamos colores vacíos
|
|
title_gen = title_gen.replace(" []", "").strip() #Quitamos etiquetas vacías
|
|
|
|
if not unify_status: #Si Titulos Inteligentes NO seleccionados:
|
|
title_gen = '**- [COLOR gold]Enlaces Ver: [/COLOR]%s[COLOR gold] -**[/COLOR]' % (title_gen)
|
|
else:
|
|
title_gen = '[COLOR gold]Enlaces Ver: [/COLOR]%s' % (title_gen)
|
|
|
|
if config.get_setting("quit_channel_name", "videolibrary") == 1 and item_local.contentChannel == "videolibrary":
|
|
title_gen = '%s: %s' % (item_local.channel.capitalize(), title_gen)
|
|
|
|
itemlist.append(item_local.clone(title=title_gen)) #Título con todos los datos del vídeo
|
|
|
|
#Ahora pintamos el link del Torrent, si lo hay
|
|
if item_local.url: # Hay Torrent ?
|
|
item_local.title = '[COLOR yellow][?][/COLOR] [COLOR yellow][Torrent][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (item_local.quality, str(item_local.language)) #Preparamos título de Torrent
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title).strip() #Quitamos etiquetas vacías
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', item_local.title).strip() #Quitamos colores vacíos
|
|
item_local.alive = "??" #Calidad del link sin verificar
|
|
item_local.action = "play" #Visualizar vídeo
|
|
|
|
itemlist.append(item_local.clone()) #Pintar pantalla
|
|
|
|
logger.debug("TORRENT: " + item_local.url + " / title gen/torr: " + title_gen + " / " + title + " / calidad: " + item_local.quality + " / tamaño: " + size + " / content: " + item_local.contentTitle + " / " + item_local.contentSerieName)
|
|
#logger.debug(item_local)
|
|
|
|
# VER vídeos, descargar vídeos un link, o múltiples links
|
|
host_dom = host.replace("https://", "").replace("http://", "").replace("www.", "")
|
|
data = data.replace("http://tumejorserie.com/descargar/url_encript.php?link=", "(")
|
|
data = re.sub(r'javascript:;" onClick="popup\("http:\/\/(?:www.)?' + host_dom + '\w{1,9}\/library\/include\/ajax\/get_modallinks.php\?links=', "", data)
|
|
|
|
# Nuevo sistema de scrapeo de servidores creado por Torrentlocula, compatible con otros clones de Newpct1
|
|
patron = '<div class=\"box1\"[^<]+<img src=\"([^<]+)?" style[^<]+><\/div[^<]+<div class="box2">([^<]+)?<\/div[^<]+<div class="box3">([^<]+)?'
|
|
patron += '<\/div[^<]+<div class="box4">([^<]+)?<\/div[^<]+<div class="box5"><a href=(.*?)? rel.*?'
|
|
patron += '<\/div[^<]+<div class="box6">([^<]+)?<'
|
|
|
|
enlaces_ver = re.compile(patron, re.DOTALL).findall(data)
|
|
enlaces_descargar = enlaces_ver
|
|
#logger.debug(enlaces_ver)
|
|
|
|
#Recorre todos los links de VER, si está permitido
|
|
cnt_enl_ver = 1
|
|
cnt_enl_verif = 1
|
|
for logo, servidor, idioma, calidad, enlace, title in enlaces_ver:
|
|
if ver_enlaces_veronline == 0: #Si no se quiere Ver Online, se sale del bloque
|
|
break
|
|
if "ver" in title.lower():
|
|
servidor = servidor.replace("streamin", "streaminto")
|
|
|
|
if servidor.capitalize() in excluir_enlaces_veronline: #Servidor excluido, pasamos al siguiente
|
|
continue
|
|
mostrar_server = True
|
|
if config.get_setting("hidepremium"): #Si no se aceptan servidore premium, se ignoran
|
|
mostrar_server = servertools.is_server_enabled(servidor)
|
|
|
|
#logger.debug("VER: url: " + enlace + " / title: " + title + " / servidor: " + servidor + " / idioma: " + idioma)
|
|
|
|
#Si el servidor es válido, se comprueban si los links están activos
|
|
if mostrar_server:
|
|
try:
|
|
if cnt_enl_ver <= ver_enlaces_veronline or ver_enlaces_veronline == -1:
|
|
devuelve = servertools.findvideosbyserver(enlace, servidor) #existe el link ?
|
|
if verificar_enlaces_veronline == 0:
|
|
cnt_enl_ver += 1
|
|
else:
|
|
break #Si se ha agotado el contador de verificación, se sale de Ver Online
|
|
|
|
if devuelve: #Hay link
|
|
enlace = devuelve[0][1] #Se guarda el link
|
|
item_local.alive = "??" #Se asume poe defecto que es link es dudoso
|
|
if verificar_enlaces_veronline != 0: #Se quiere verificar si el link está activo?
|
|
if cnt_enl_verif <= verificar_enlaces_veronline or verificar_enlaces_veronline == -1: #contador?
|
|
item_local.alive = servertools.check_video_link(enlace, servidor) #activo el link ?
|
|
if verificar_enlaces_veronline_validos: #Los links tienen que ser válidos para contarlos?
|
|
if item_local.alive == "Ok": #Sí
|
|
cnt_enl_verif += 1 #Movemos los contadores
|
|
cnt_enl_ver += 1 #Movemos los contadores
|
|
else: #Si no es necesario que sean links válidos, sumamos
|
|
cnt_enl_verif += 1 #Movemos los contadores
|
|
cnt_enl_ver += 1 #Movemos los contadores
|
|
else:
|
|
break #Si se ha agotado el contador de verificación, se sale de Ver Online
|
|
|
|
#Si el link no está activo se ignora
|
|
if item_local.alive == "??": #dudoso
|
|
item_local.title = '[COLOR yellow][?][/COLOR] [COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (servidor.capitalize(), item_local.quality, str(item_local.language))
|
|
elif item_local.alive.lower() == "no": #No está activo. Lo preparo, pero no lo pinto
|
|
item_local.title = '[COLOR red][%s][/COLOR] [COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (item_local.alive, servidor.capitalize(), item_local.quality, str(item_local.language))
|
|
logger.debug(item_local.alive + ": ALIVE / " + title + " / " + servidor + " / " + enlace)
|
|
raise
|
|
else: #Sí está activo
|
|
item_local.title = '[COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (servidor.capitalize(), item_local.quality, str(item_local.language))
|
|
|
|
#Preparamos el resto de variables de Item para ver los vídeos en directo
|
|
item_local.action = "play"
|
|
item_local.server = servidor
|
|
item_local.url = enlace
|
|
item_local.title = item_local.title.replace("[]", "").strip()
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title).strip()
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', item_local.title).strip()
|
|
itemlist.append(item_local.clone())
|
|
except:
|
|
pass
|
|
|
|
#Ahora vemos los enlaces de DESCARGAR
|
|
if len(enlaces_descargar) > 0 and ver_enlaces_descargas != 0:
|
|
|
|
#Pintamos un pseudo-título de Descargas
|
|
if not unify_status: #Si Titulos Inteligentes NO seleccionados:
|
|
itemlist.append(item_local.clone(title="[COLOR gold]**- Enlaces Descargar: -**[/COLOR]", action=""))
|
|
else:
|
|
itemlist.append(item_local.clone(title="[COLOR gold] Enlaces Descargar: [/COLOR]", action=""))
|
|
|
|
#Recorre todos los links de DESCARGAR
|
|
cnt_enl_ver = 1
|
|
cnt_enl_verif = 1
|
|
for logo, servidor, idioma, calidad, enlace, title in enlaces_descargar:
|
|
if ver_enlaces_descargas == 0:
|
|
break
|
|
|
|
if "Ver" not in title:
|
|
servidor = servidor.replace("uploaded", "uploadedto")
|
|
partes = enlace.split(" ") #Partimos el enlace en cada link de las partes
|
|
title = "Descarga" #Usamos la palabra reservada de Unify para que no formatee el título
|
|
|
|
if servidor.capitalize() in excluir_enlaces_descargas: #Servidor excluido, pasamos al siguiente
|
|
continue
|
|
|
|
#logger.debug("DESCARGAR: url: " + enlace + " / title: " + title + title + " / servidor: " + servidor + " / idioma: " + idioma)
|
|
|
|
#Recorremos cada una de las partes. Vemos si el primer link está activo. Si no lo está ignoramos todo el enlace
|
|
p = 1
|
|
for enlace in partes:
|
|
if not unify_status: #Si titles Inteligentes NO seleccionados:
|
|
parte_title = "[COLOR yellow][%s][/COLOR] %s (%s/%s) [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]" % (servidor.capitalize(), title, p, len(partes), item_local.quality, str(item_local.language))
|
|
else:
|
|
parte_title = "[COLOR yellow]%s-[/COLOR] %s %s/%s [COLOR limegreen]-%s[/COLOR] [COLOR red]-%s[/COLOR]" % (servidor.capitalize(), title, p, len(partes), item_local.quality, str(item_local.language))
|
|
p += 1
|
|
mostrar_server = True
|
|
if config.get_setting("hidepremium"): #Si no se aceptan servidore premium, se ignoran
|
|
mostrar_server = servertools.is_server_enabled(servidor)
|
|
|
|
#Si el servidor es válido, se comprueban si los links están activos
|
|
if mostrar_server:
|
|
try:
|
|
if cnt_enl_ver <= ver_enlaces_descargas or ver_enlaces_descargas == -1:
|
|
devuelve = servertools.findvideosbyserver(enlace, servidor) #activo el link ?
|
|
if verificar_enlaces_descargas == 0:
|
|
cnt_enl_ver += 1
|
|
else:
|
|
ver_enlaces_descargas = 0 #FORZAR SALIR de DESCARGAS
|
|
break #Si se ha agotado el contador de verificación, se sale de "Enlace"
|
|
|
|
if devuelve:
|
|
enlace = devuelve[0][1]
|
|
|
|
#Verifica si está activo el primer link. Si no lo está se ignora el enlace-servidor entero
|
|
if p <= 2:
|
|
item_local.alive = "??" #Se asume poe defecto que es link es dudoso
|
|
if verificar_enlaces_descargas != 0: #Se quiere verificar si el link está activo?
|
|
if cnt_enl_verif <= verificar_enlaces_descargas or verificar_enlaces_descargas == -1: #contador?
|
|
item_local.alive = servertools.check_video_link(enlace, servidor) #activo el link ?
|
|
if verificar_enlaces_descargas_validos: #Los links tienen que ser válidos para contarlos?
|
|
if item_local.alive == "Ok": #Sí
|
|
cnt_enl_verif += 1 #Movemos los contadores
|
|
cnt_enl_ver += 1 #Movemos los contadores
|
|
else: #Si no es necesario que sean links válidos, sumamos
|
|
cnt_enl_verif += 1 #Movemos los contadores
|
|
cnt_enl_ver += 1 #Movemos los contadores
|
|
else:
|
|
ver_enlaces_descargas = 0 #FORZAR SALIR de DESCARGAS
|
|
break #Si se ha agotado el contador de verificación, se sale de "Enlace"
|
|
|
|
if item_local.alive == "??": #dudoso
|
|
if not unify_status: #Si titles Inteligentes NO seleccionados:
|
|
parte_title = '[COLOR yellow][?][/COLOR] %s' % (parte_title)
|
|
else:
|
|
parte_title = '[COLOR yellow]%s[/COLOR]-%s' % (item_local.alive, parte_title)
|
|
elif item_local.alive.lower() == "no": #No está activo. Lo preparo, pero no lo pinto
|
|
if not unify_status: #Si titles Inteligentes NO seleccionados:
|
|
parte_title = '[COLOR red][%s][/COLOR] %s' % (item_local.alive, parte_title)
|
|
else:
|
|
parte_title = '[COLOR red]%s[/COLOR]-%s' % (item_local.alive, parte_title)
|
|
logger.debug(item_local.alive + ": ALIVE / " + title + " / " + servidor + " / " + enlace)
|
|
break
|
|
|
|
#Preparamos el resto de variables de Item para descargar los vídeos
|
|
item_local.action = "play"
|
|
item_local.server = servidor
|
|
item_local.url = enlace
|
|
item_local.title = parte_title.replace("[]", "").strip()
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title).strip()
|
|
item_local.title = re.sub(r'\[COLOR \w+\]-\[\/COLOR\]', '', item_local.title).strip()
|
|
itemlist.append(item_local.clone())
|
|
except:
|
|
pass
|
|
|
|
return itemlist
|
|
|
|
|
|
def episodios(item):
|
|
logger.info()
|
|
itemlist = []
|
|
|
|
data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(item.url).data)
|
|
|
|
#Busca y pre-carga todas las páginas de episodios que componen las serie, para obtener la url de cada página
|
|
pattern = '<ul class="%s">(.*?)</ul>' % "pagination" # item.pattern
|
|
pagination = scrapertools.find_single_match(data, pattern)
|
|
if pagination:
|
|
pattern = '<li><a href="([^"]+)">Last<\/a>' #Busca última página
|
|
full_url = scrapertools.find_single_match(pagination, pattern)
|
|
url, last_page = scrapertools.find_single_match(full_url, r'(.*?\/pg\/)(\d+)')
|
|
list_pages = [item.url]
|
|
for x in range(2, int(last_page) + 1): #carga cada página para obtener la url de la siguiente
|
|
#LAS SIGUIENTES 3 LINEAS ANULADAS: no es necesario leer la pagína siguiente. Se supone que está activa
|
|
#response = httptools.downloadpage('%s%s'% (url,x))
|
|
#if response.sucess:
|
|
# list_pages.append("%s%s" % (url, x)) #Guarda la url de la siguiente página en una lista
|
|
list_pages.append("%s%s" % (url, x)) #Guarda la url de la siguiente página en una lista
|
|
else:
|
|
list_pages = [item.url]
|
|
|
|
for index, page in enumerate(list_pages): #Recorre la lista de páginas
|
|
data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(page).data)
|
|
data = unicode(data, "iso-8859-1", errors="replace").encode("utf-8")
|
|
data = data.replace("chapters", "buscar-list") #Compatibilidad con mispelisy.series.com
|
|
pattern = '<ul class="%s">(.*?)</ul>' % "buscar-list" # item.pattern
|
|
if scrapertools.find_single_match(data, pattern):
|
|
data = scrapertools.get_match(data, pattern)
|
|
else:
|
|
logger.debug(item)
|
|
logger.debug("patron: " + pattern + " / data: " + data)
|
|
return itemlist
|
|
|
|
if "pelisyseries.com" in host:
|
|
pattern = '<li[^>]*><div class.*?src="(?P<thumb>[^"]+)?".*?<a class.*?href="(?P<url>[^"]+).*?<h3[^>]+>(?P<info>.*?)?<\/h3>.*?<\/li>'
|
|
else:
|
|
pattern = '<li[^>]*><a href="(?P<url>[^"]+).*?<img.*?src="(?P<thumb>[^"]+)?".*?<h2[^>]+>(?P<info>.*?)?<\/h2>'
|
|
matches = re.compile(pattern, re.DOTALL).findall(data)
|
|
#logger.debug("patron: " + pattern)
|
|
#logger.debug(matches)
|
|
|
|
#Empezamos a generar cada episodio
|
|
season = "1"
|
|
for url, thumb, info in matches:
|
|
if "pelisyseries.com" in host: #En esta web están en diferente orden
|
|
interm = url
|
|
url = thumb
|
|
thumb = interm
|
|
|
|
item_local = item.clone() #Creamos copia local de Item por episodio
|
|
item_local.url = url
|
|
item_local.contentThumbnail = thumb
|
|
estado = True #Buena calidad de datos por defecto
|
|
|
|
if "<span" in info: # new style
|
|
pattern = ".*?[^>]+>.*?Temporada\s*(?P<season>\d+)?.*?Capitulo(?:s)?\s*(?P<episode>\d+)?" \
|
|
"(?:.*?(?P<episode2>\d+)?)<.+?<span[^>]+>(?P<lang>.*?)?<\/span>\s*Calidad\s*<span[^>]+>" \
|
|
"[\[]\s*(?P<quality>.*?)?\s*[\]]<\/span>"
|
|
if "Especial" in info: # Capitulos Especiales
|
|
pattern = ".*?[^>]+>.*?Temporada.*?\[.*?(?P<season>\d+).*?\].*?Capitulo.*?\[\s*(?P<episode>\d+).*?\]?(?:.*?(?P<episode2>\d+)?)<.+?<span[^>]+>(?P<lang>.*?)?<\/span>\s*Calidad\s*<span[^>]+>[\[]\s*(?P<quality>.*?)?\s*[\]]<\/span>"
|
|
|
|
if not scrapertools.find_single_match(info, pattern): #en caso de error de formato, creo uno básico
|
|
logger.debug("patron episodioNEW: " + pattern)
|
|
logger.debug(info)
|
|
logger.debug(item_local.url)
|
|
info = '><strong>%sTemporada %s Capitulo 0</strong> - <span >Español Castellano</span> Calidad <span >[%s]</span>' % (item_local.contentSerieName, season, item_local.quality)
|
|
|
|
else: # old style. Se intenta buscar un patrón que encaje con los diversos formatos antiguos. Si no, se crea
|
|
pattern = '\[(?P<quality>.*?)\]\[Cap.(?P<season>\d).*?(?P<episode>\d{2})(?:_(?P<season2>\d+)(?P<episode2>\d{2}))?\].*?(?P<lang>.*)?' #Patrón básico por defecto
|
|
|
|
if scrapertools.find_single_match(info, '\[\d{3}\]'):
|
|
info = re.sub(r'\[(\d{3}\])', r'[Cap.\1', info)
|
|
elif scrapertools.find_single_match(info, '\[Cap.\d{2}_\d{2}\]'):
|
|
info = re.sub(r'\[Cap.(\d{2})_(\d{2})\]', r'[Cap.1\1_1\2]', info)
|
|
elif scrapertools.find_single_match(info, '\[Cap.([A-Za-z]+)\]'):
|
|
info = re.sub(r'\[Cap.([A-Za-z]+)\]', '[Cap.100]', info)
|
|
if scrapertools.find_single_match(info, '\[Cap.\d{2,3}'):
|
|
pattern = "\[(?P<quality>.*?)\].*?\[Cap.(?P<season>\d).*?(?P<episode>\d{2})(?:_(?P<season2>\d+)" \
|
|
"(?P<episode2>\d{2}))?.*?\].*?(?:\[(?P<lang>.*?)\])?"
|
|
elif scrapertools.find_single_match(info, 'Cap.\d{2,3}'):
|
|
pattern = ".*?Temp.*?\s(?P<quality>.*?)\s.*?Cap.(?P<season>\d).*?(?P<episode>\d{2})(?:_(?P<season2>\d+)(?P<episode2>\d{2}))?.*?\s(?P<lang>.*)?"
|
|
elif scrapertools.find_single_match(info, '(?P<quality>.*?)?(?P<season>\d)[x|X|\.](?P<episode>\d{2})\s?(?:_(?P<season2>\d+)(?P<episode2>\d{2}))?.*?(?P<lang>.*)?'):
|
|
pattern = "(?P<quality>.*?)?(?P<season>\d)[x|X|\.](?P<episode>\d{2})\s?(?:_(?P<season2>\d+)(?P<episode2>\d{2}))?.*?(?P<lang>.*)?"
|
|
estado = False #Mala calidad de datos
|
|
if not scrapertools.find_single_match(info, pattern): #en caso de error de formato, creo uno básico
|
|
logger.debug("patron episodioOLD: " + pattern)
|
|
logger.debug(info)
|
|
logger.debug(item_local.url)
|
|
info = '%s - Temp.%s [%s][Cap.%s00][Spanish]' % (item_local.contentSerieName, season, item_local.quality, season)
|
|
estado = False #Mala calidad de datos
|
|
|
|
r = re.compile(pattern)
|
|
match = [m.groupdict() for m in r.finditer(info)][0]
|
|
|
|
if match['season'] is None: match['season'] = season #Si no se encuentran valores, pero poner lo básico
|
|
if match['episode'] is None: match['episode'] = "0"
|
|
|
|
if match['quality'] and not item_local.quality and estado == True:
|
|
item_local.quality = match['quality'] #Si hay quality se coge, si no, la de la serie
|
|
item_local.quality = item_local.quality.replace("ALTA DEFINICION", "HDTV")
|
|
|
|
if match['lang'] and estado == False:
|
|
match['lang'] = match['lang'].replace("- ", "")
|
|
item_local.infoLabels['episodio_titulo'] = match['lang']
|
|
item_local.infoLabels['title'] = item_local.infoLabels['episodio_titulo']
|
|
|
|
if match["episode2"]: #Hay episodio dos? es una entrada múltiple?
|
|
item_local.title = "%sx%s al %s -" % (str(match["season"]), str(match["episode"]).zfill(2), str(match["episode2"]).zfill(2)) #Creamos un título con el rango de episodios
|
|
else: #Si es un solo episodio, se formatea ya
|
|
item_local.title = "%sx%s -" % (match["season"], str(match["episode"]).zfill(2))
|
|
|
|
item_local.contentEpisodeNumber = match['episode']
|
|
item_local.contentSeason = match['season']
|
|
item_local.action = "findvideos"
|
|
item_local.extra = "episodios"
|
|
|
|
itemlist.append(item_local.clone())
|
|
|
|
logger.debug("title: " + item_local.title + " / url: " + item_local.url + " / calidad: " + item_local.quality + " / Season: " + str(item_local.contentSeason) + " / EpisodeNumber: " + str(item_local.contentEpisodeNumber))
|
|
|
|
# Pasada por TMDB y clasificación de lista por temporada y episodio
|
|
tmdb.set_infoLabels(itemlist, seekTmdb = True)
|
|
if len(itemlist) > 1:
|
|
itemlist = sorted(itemlist, key=lambda it: (int(it.contentSeason), int(it.contentEpisodeNumber)))
|
|
|
|
# Pasada para maqullaje de los títulos obtenidos desde TMDB
|
|
num_episodios = 1
|
|
num_temporada = 1
|
|
for item_local in itemlist:
|
|
|
|
# Si no hay datos de TMDB, pongo los datos locales que conozco
|
|
if item_local.infoLabels['aired']:
|
|
item_local.infoLabels['year'] = scrapertools.find_single_match(str(item_local.infoLabels['aired']), r'\/(\d{4})')
|
|
|
|
rating = ''
|
|
if item_local.infoLabels['rating'] and item_local.infoLabels['rating'] != '0.0':
|
|
rating = float(item_local.infoLabels['rating'])
|
|
rating = round(rating, 1)
|
|
|
|
#Salvamos en número de episodios de la temporada
|
|
if num_temporada != item_local.contentSeason:
|
|
num_temporada = item_local.contentSeason
|
|
num_episodios = 0
|
|
if item_local.infoLabels['temporada_num_episodios']:
|
|
num_episodios = item_local.infoLabels['temporada_num_episodios']
|
|
|
|
#Preparamos el título para que sea compatible con Añadir Serie a Videoteca
|
|
if item_local.infoLabels['episodio_titulo']:
|
|
if "al" in item_local.title: #Si son episodios múltiples, ponemos nombre de serie
|
|
item_local.title = '%s %s' % (item_local.title, item_local.contentSerieName)
|
|
item_local.infoLabels['episodio_titulo'] = '%s %s' % (scrapertools.find_single_match(item_local.title, r'(al \d+)'), item_local.contentSerieName)
|
|
else:
|
|
item_local.title = '%s %s' % (item_local.title, item_local.infoLabels['episodio_titulo'])
|
|
if item_local.infoLabels['year']:
|
|
item_local.infoLabels['episodio_titulo'] = '%s [%s]' % (item_local.infoLabels['episodio_titulo'], item_local.infoLabels['year'])
|
|
if rating:
|
|
item_local.infoLabels['episodio_titulo'] = '%s [%s]' % (item_local.infoLabels['episodio_titulo'], rating)
|
|
else:
|
|
item_local.title = '%s %s' % (item_local.title, item_local.contentSerieName)
|
|
item_local.infoLabels['episodio_titulo'] = '%s [%s] [%s]' % (item_local.contentSerieName, item_local.infoLabels['year'], rating)
|
|
item_local.infoLabels['title'] = item_local.infoLabels['episodio_titulo']
|
|
|
|
item_local.title = '%s [%s] [%s] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (item_local.title, item_local.infoLabels['year'], rating, item_local.quality, str(item_local.language))
|
|
|
|
#Quitamos campos vacíos
|
|
item_local.infoLabels['episodio_titulo'] = item_local.infoLabels['episodio_titulo'].replace(" []", "").strip()
|
|
item_local.title = item_local.title.replace(" []", "").strip()
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title).strip()
|
|
item_local.title = re.sub(r'\s\[COLOR \w+\]-\[\/COLOR\]', '', item_local.title).strip()
|
|
if num_episodios < item_local.contentEpisodeNumber:
|
|
num_episodios = item_local.contentEpisodeNumber
|
|
if num_episodios and not item_local.infoLabels['temporada_num_episodios']:
|
|
item_local.infoLabels['temporada_num_episodios'] = num_episodios
|
|
|
|
#logger.debug("title=[" + item_local.title + "], url=[" + item_local.url + "], item=[" + str(item_local) + "]")
|
|
|
|
if config.get_videolibrary_support() and len(itemlist) > 0:
|
|
title = ''
|
|
if item_local.infoLabels['temporada_num_episodios']:
|
|
title = ' [Temp. de %s ep.]' % item_local.infoLabels['temporada_num_episodios']
|
|
|
|
itemlist.append(item.clone(title="[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]" + title, action="add_serie_to_library", extra="episodios"))
|
|
|
|
return itemlist
|
|
|
|
def search(item, texto):
|
|
logger.info("search:" + texto)
|
|
# texto = texto.replace(" ", "+")
|
|
|
|
try:
|
|
item.post = "q=%s" % texto
|
|
item.pattern = "buscar-list"
|
|
itemlist = listado_busqueda(item)
|
|
|
|
return itemlist
|
|
|
|
# Se captura la excepción, para no interrumpir al buscador global si un canal falla
|
|
except:
|
|
import sys
|
|
for line in sys.exc_info():
|
|
logger.error("%s" % line)
|
|
return []
|
|
|
|
def newest(categoria):
|
|
logger.info()
|
|
itemlist = []
|
|
item = Item()
|
|
|
|
item.title = "newest"
|
|
item.category = "newest"
|
|
item.action = "listado"
|
|
item.channel = scrapertools.find_single_match(host, r'(\w+)\.com\/')
|
|
|
|
try:
|
|
if categoria == 'peliculas':
|
|
item.url = host+'peliculas/'
|
|
item.extra = "peliculas"
|
|
itemlist = listado(item)
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
if categoria == 'series':
|
|
item.url = host+'series/'
|
|
item.extra = "series"
|
|
itemlist.extend(listado(item))
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
if categoria == '4k':
|
|
item.url = host+'peliculas-hd/4kultrahd/'
|
|
item.extra = "peliculas"
|
|
itemlist.extend(listado(item))
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
if categoria == 'anime':
|
|
item.url = host+'anime/'
|
|
item.extra = "peliculas"
|
|
itemlist.extend(listado(item))
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
if categoria == 'documentales':
|
|
item.url = host+'documentales/'
|
|
item.extra = "varios"
|
|
itemlist.extend(listado(item))
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
if categoria == 'latino':
|
|
item.url = host+'peliculas-latino/'
|
|
item.extra = "peliculas"
|
|
itemlist.extend(listado(item))
|
|
if ">> Página siguiente" in itemlist[-1].title:
|
|
itemlist.pop()
|
|
|
|
# Se captura la excepción, para no interrumpir al canal novedades si un canal falla
|
|
except:
|
|
import sys
|
|
for line in sys.exc_info():
|
|
logger.error("{0}".format(line))
|
|
return []
|
|
|
|
return itemlist
|