def findvideos(item):
logger.info("pelisalacarta.channels.animeflv_me findvideos")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=CHANNEL_DEFAULT_HEADERS, host=CHANNEL_HOST)
data = re.sub(r"\n|\r|\t|\s{2}| |<Br>|<BR>|<br>|<br/>|<br />|-\s", "", data);
urlApi = scrapertools.find_single_match(data, "http:\/\/api\.animeflv\.me\/[^\"]+")
data = scrapertools.anti_cloudflare(urlApi, headers=CHANNEL_DEFAULT_HEADERS)
data = scrapertools.find_single_match(data, "var part = \[([^\]]+)")
patron = '"([^"]+)"'
matches = re.compile(patron, re.DOTALL).findall(data)
list_quality = ["360", "480", "720", "1080"]
# eliminamos la fecha del titulo a mostrar
patron = "(.+?)\s\(\d{1,2}/\d{1,2}/\d{4}\)"
title = scrapertools.find_single_match(item.title, patron)
for _id, scrapedurl in enumerate(matches):
itemlist.append(Item(channel=item.channel, action="play", url=scrapedurl, show=re.escape(item.show), fanart="",
title="Ver en calidad [{0}]".format(list_quality[_id]), thumbnail="", plot=item.plot,
folder=True, fulltitle=title, viewmode="movies_with_plot"))
return sorted(itemlist, key=lambda it: int(scrapertools.find_single_match(it.title, "\[(.+?)\]")), reverse=True)
def play(item):
logger.info("[cb01anime.py] play")
if '/goto/' in item.url:
item.url = item.url.split('/goto/')[-1].decode('base64')
item.url = item.url.replace('http://cineblog01.pw', 'http://k4pp4.pw')
logger.debug("##############################################################")
if "go.php" in item.url:
data = scrapertools.anti_cloudflare(item.url, headers)
try:
data = scrapertools.get_match(data, 'window.location.href = "([^"]+)";')
except IndexError:
try:
# data = scrapertools.get_match(data, r'<a href="([^"]+)">clicca qui</a>')
# In alternativa, dato che a volte compare "Clicca qui per proseguire":
data = scrapertools.get_match(data, r'<a href="([^"]+)".*?class="btn-wrapper">.*?licca.*?</a>')
except IndexError:
data = scrapertools.get_header_from_response(item.url, headers=headers, header_to_get="Location")
while 'vcrypt' in data:
data = scrapertools.get_header_from_response(data, headers=headers, header_to_get="Location")
logger.debug("##### play go.php data ##\n%s\n##" % data)
elif "/link/" in item.url:
data = scrapertools.anti_cloudflare(item.url, headers)
from lib import jsunpack
try:
data = scrapertools.get_match(data, "(eval\(function\(p,a,c,k,e,d.*?)</script>")
data = jsunpack.unpack(data)
logger.debug("##### play /link/ unpack ##\n%s\n##" % data)
except IndexError:
logger.debug("##### The content is yet unpacked ##\n%s\n##" % data)
data = scrapertools.find_single_match(data, 'var link(?:\s)?=(?:\s)?"([^"]+)";')
while 'vcrypt' in data:
data = scrapertools.get_header_from_response(data, headers=headers, header_to_get="Location")
logger.debug("##### play /link/ data ##\n%s\n##" % data)
else:
data = item.url
logger.debug("##### play else data ##\n%s\n##" % data)
logger.debug("##############################################################")
itemlist = servertools.find_video_items(data=data)
for videoitem in itemlist:
videoitem.title = item.show
videoitem.fulltitle = item.fulltitle
videoitem.show = item.show
videoitem.thumbnail = item.thumbnail
videoitem.channel = __channel__
return itemlist
def play(item):
logger.info("pelisalacarta.channels.pelispedia play url={0}".format(item.url))
itemlist = []
# Para videos flash y html5
if "pelispedia.tv" in item.url:
key = scrapertools.find_single_match(item.url, 'index.php\?id=([^&]+)&sub=([^&]+)&.+?imagen=([^&]+)')
subtitle = ""
thumbnail = ""
if len(key) > 2:
thumbnail = key[2]
if key[1] != "":
url_sub = "http://www.pelispedia.tv/sub/%s.srt" % key[1]
data_sub = scrapertools.anti_cloudflare(url_sub, host=CHANNEL_HOST)
subtitle = save_sub(data_sub)
if "Player_Html5" in item.url:
url = "http://www.pelispedia.tv/Pe_Player_Html5/pk/pk_2/plugins/protected.php"
post = "fv=21&url="+urllib.quote(key[0])+"&sou=pic"
else:
url = "http://www.pelispedia.tv/Pe_flsh/plugins/gkpluginsphp.php"
post = "link="+urllib.quote(key[0])
data = scrapertools.cache_page(url, post=post, headers=CHANNEL_DEFAULT_HEADERS)
media_urls = scrapertools.find_multiple_matches(data, '(?:link|url)":"([^"]+)"')
# Si hay varias urls se añade la última que es la de mayor calidad
if len(media_urls) > 0:
url = media_urls[len(media_urls)-1].replace("\\", "")
itemlist.append(Item(channel=__channel__, title=item.title, url=url, server="directo", action="play",
subtitle=subtitle, thumbnail=thumbnail))
elif "pelispedia.biz" in item.url:
logger.info("estoy en el otro html5")
key = scrapertools.find_single_match(item.url, 'v=([^&]+).+?imagen=([^&]+)')
thumbnail = ""
if len(key) > 1:
thumbnail = key[1]
data = scrapertools.anti_cloudflare(item.url , host=CHANNEL_HOST , headers=CHANNEL_DEFAULT_HEADERS )
media_url = scrapertools.find_single_match(data, '"file":"([^"]+)"').replace("\\", "")
sub = scrapertools.find_single_match(data, 'file:\s"([^"]+)".+?label:\s"Spanish"')
itemlist.append(Item(channel=__channel__, title=item.title, url=media_url, server="directo", action="play",
subtitle=sub, thumbnail=thumbnail))
else:
itemlist = servertools.find_video_items(data=item.url)
for videoitem in itemlist:
videoitem.title = item.title
videoitem.channel = __channel__
return itemlist
def quality(item):
logger.info("[itastreaming.py] genere")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<a>Qualità</a>(.+?)</ul>'
data = scrapertools.find_single_match(data, patron)
patron = '<li id=".*?'
patron += 'href="([^"]+)".*?'
patron += '>([^"]+)</a>'
matches = re.compile(patron, re.DOTALL).findall(data)
scrapertools.printMatches(matches)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapedtitle.replace('&', '-')
itemlist.append(
Item(channel=__channel__,
action="fichas",
title=scrapedtitle,
url=scrapedurl,
folder=True))
return itemlist
def listado_genero(item):
logger.info("pelisalacarta.channels.pelispedia listado_genero")
itemlist = []
data = scrapertools.anti_cloudflare(item.url , host=CHANNEL_HOST , headers=CHANNEL_DEFAULT_HEADERS )
data = re.sub(r"\n|\r|\t|\s{2}| |<Br>|<BR>|<br>|<br/>|<br />|-\s", "", data)
if item.extra == "movies":
cadena = 'movies/all/?gender='
patron = '<select name="gender" id="genres" class="auxBtn1">.*?</select>'
data = scrapertools.find_single_match(data, patron)
patron = '<option value="([^"]+)".+?>(.*?)</option>'
else:
cadena = "series/genero/"
patron = '<select id="genres">.*?</select>'
data = scrapertools.find_single_match(data, patron)
patron = '<option name="([^"]+)".+?>(.*?)</option>'
matches = re.compile(patron, re.DOTALL).findall(data)
for key, value in matches[1:]:
cadena2 = cadena + key
if item.extra != "movies":
cadena2 += "/"
itemlist.append(Item(channel=__channel__, action="listado", title=value, url=urlparse.urljoin(CHANNEL_HOST, cadena2),
extra=item.extra, text_color= color2, fanart=fanart_host,
thumbnail="https://raw.githubusercontent.com/master-1970/resources/master/images/genres/0/Genre.png"))
return itemlist
def cerca(item):
logger.info("streamondemand.channels.guardaserie fichas")
itemlist = []
## Descarga la página
data = re.sub(
r'\t|\n|\r',
'',
scrapertools.anti_cloudflare(item.url, headers)
)
patron = '<div class="search_thumbnail">.*?<a class="search_link" href="([^"]+)" rel="bookmark" title="([^"]+)">.*?<img src="([^"]+)" />.*?</a>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedtitle, scrapedthumbnail in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
if scrapedtitle.startswith("Guarda "):
scrapedtitle = scrapedtitle[7:]
itemlist.append(infoSod(
Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
show=scrapedtitle,
thumbnail=scrapedthumbnail), tipo='tv'))
return itemlist
def getsearch(item):
logger.info("[hdgratis.py] fichas")
itemlist = []
# Descarga la pagina
data = scrapertools.anti_cloudflare(item.url, headers)
# fix - calidad
# ------------------------------------------------
cookies = ""
matches = re.compile('(.hdgratis.org.*?)\n', re.DOTALL).findall(config.get_cookie_data())
for cookie in matches:
name = cookie.split('\t')[5]
value = cookie.split('\t')[6]
cookies += name + "=" + value + ";"
headers.append(['Cookie', cookies[:-1]])
import urllib
_headers = urllib.urlencode(dict(headers))
# ------------------------------------------------
patron = '<div class="col-xs-2">.*?'
patron += 'href="([^"]+)".*?'
patron += 'title="([^"]+)".*?'
patron += '<img src="([^"]+)".*?'
matches = re.compile(patron, re.DOTALL).findall(data)
for scraped_2, scrapedtitle, scrapedthumbnail in matches:
scrapedurl = scraped_2
title = scrapertools.decodeHtmlentities(scrapedtitle)
# title += " (" + scrapedcalidad + ")
# ------------------------------------------------
scrapedthumbnail += "|" + _headers
# ------------------------------------------------
itemlist.append(infoSod(
Item(channel=__channel__,
action="findvideos",
title=title,
url=scrapedurl,
thumbnail=scrapedthumbnail,
fulltitle=title,
show=scrapedtitle), tipo='movie'))
# Paginación
next_page = re.compile('<link rel="next" href="(.+?)"/>', re.DOTALL).findall(data)
for page in next_page:
next_page = page
if next_page != "":
itemlist.append(
Item(channel=__channel__,
action="fichas",
title="[COLOR orange]Successivo >>[/COLOR]",
url=next_page,
thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"))
return itemlist
def ultimi(item):
logger.info("streamondemand.channels.guardaserie fichas")
itemlist = []
## Descarga la página
data = re.sub(
r'\t|\n|\r',
'',
scrapertools.anti_cloudflare(item.url, headers)
)
# data = scrapertools.cache_page(item.url)
patron = '<p>Nuove Puntate delle SERIE TV, Aggiunte OGGI:</p>(.*?)<div id="disclamer">'
data = scrapertools.find_single_match(data, patron)
patron = '<li><a href="([^"]+)[^>]+>([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
fulltitle = scrapedtitle[:scrapedtitle.find('-')]
scrapedurl = urlparse.urljoin(host, scrapedurl)
scrapedthumbnail = ""
itemlist.append(
Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
fulltitle=fulltitle,
show=fulltitle,
url=scrapedurl))
return itemlist
def genere(item):
logger.info("[hdgratis.py] genere")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<ul>(.+?)</ul>'
# patron = '<li class="cat-item cat-item.*?"><a href="([^"]+)">([^"]+)</a>.*?</li>'
data = scrapertools.find_single_match(data, patron)
patron = '<li class=".*?'
patron += 'href="([^"]+)".*?'
patron += '>([^"]+)</a>'
matches = re.compile(patron, re.DOTALL).findall(data)
scrapertools.printMatches(matches)
for scrapedurl, scrapedtitle in matches:
# scrapedtitle = scrapedtitle.replace('&','-')
itemlist.append(
Item(channel=__channel__,
action="fichas",
title=scrapedtitle,
url=scrapedurl,
folder=True))
return itemlist
def progs(item):
logger.info("streamondemand.channels.guardaserie fichas")
itemlist = []
## Descarga la página
data = re.sub(
r'\t|\n|\r',
'',
scrapertools.anti_cloudflare(item.url, headers)
)
data = scrapertools.find_single_match(data, '<a[^>]+>Programmi TV</a><ul>(.*?)</ul>')
patron = '<li><a href="([^"]+)[^>]+>([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
itemlist.append(
Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
show=scrapedtitle,
thumbnail="http://www.itrentenni.com/wp-content/uploads/2015/02/tv-series.jpg"))
return itemlist
def alfabetico(item):
logger.info("[cb01anime.py] listacompleta")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
bloque = scrapertools.get_match(data, '<option value=\'-1\'>Anime per Lettera</option>(.*?)</select>')
# The categories are the options for the combo
patron = '<option value="([^"]+)">\(([^<]+)\)</option>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
scrapertools.printMatches(matches)
for url, titulo in matches:
scrapedtitle = titulo
scrapedurl = url
scrapedthumbnail = ""
scrapedplot = ""
if (DEBUG): logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl + "]")
itemlist.append(
Item(channel=__channel__,
action="novita",
title=scrapedtitle,
url=host + scrapedurl,
thumbnail="http://www.justforpastime.net/uploads/3/8/1/5/38155083/273372_orig.jpg",
plot=scrapedplot))
return itemlist
def genere(item):
logger.info("[italiafilmvideohd.py] genere")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<div class="sub_title">Genere</div>(.+?)</div>'
data = scrapertools.find_single_match(data, patron)
patron = '<li>.*?'
patron += 'href="([^"]+)".*?'
patron += '<i>([^"]+)</i>'
matches = re.compile(patron, re.DOTALL).findall(data)
scrapertools.printMatches(matches)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapedtitle.replace('&', '-')
itemlist.append(
Item(channel=__channel__,
action="fichas",
title=scrapedtitle,
url=scrapedurl,
folder=True))
return itemlist
def episodi(item):
logger.info("[BleachAnimeManga.py]==> episodi")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
blocco = scrapertools.find_single_match(data, r'</div>\s*<td class="right Item" width="\d+%">(.*?)</table>')
patron = r'(<a href="[^"]+" target="_blank">)((?:Episodio|Streaming)\s*[0-9\.]+).*?</a>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
index = 0
for scrapedhtml, scrapedtitle in matches:
if ("Special" in scrapedtitle) or ("OAV" in scrapedtitle): continue # Salto gli OAV e i movies
if len(itemlist) > 0:
if "Streaming" in scrapedtitle: # Se c'è un link alternativo dello stesso episodio unisco la sua parte HTML con quella dell'item precedente e continuo senza aggiungere l'item
itemlist[index-1].url = itemlist[index-1].url + scrapedhtml
continue
itemlist.append(
Item(channel=__channel__,
action="findvideos",
title=scrapedtitle,
fulltitle=scrapedtitle,
contentType="episode",
url=scrapedhtml,
thumbnail=item.thumbnail,
folder=True))
index += 1
return itemlist
def listado_anio(item):
logger.info("pelisalacarta.channels.pelispedia listado_anio")
itemlist = []
data = scrapertools.anti_cloudflare(item.url , host=CHANNEL_HOST , headers=CHANNEL_DEFAULT_HEADERS )
data = re.sub(r"\n|\r|\t|\s{2}| |<Br>|<BR>|<br>|<br/>|<br />|-\s", "", data)
if item.extra == "movies":
cadena = 'movies/all/?year='
patron = '<select name="year" id="years" class="auxBtn1">.*?</select>'
data = scrapertools.find_single_match(data, patron)
patron = '<option value="([^"]+)"'
titulo = 'Películas del año '
else:
cadena = "series/anio/"
patron = '<select id="year">.*?</select>'
data = scrapertools.find_single_match(data, patron)
patron = '<option name="([^"]+)"'
titulo = 'Series del año '
matches = re.compile(patron, re.DOTALL).findall(data)
for value in matches[1:]:
cadena2 = cadena + value
if item.extra != "movies":
cadena2 += "/"
itemlist.append(Item(channel=__channel__, action="listado", title=titulo+value, extra=item.extra,
url=urlparse.urljoin(CHANNEL_HOST, cadena2), text_color= color2, fanart=fanart_host
))
return itemlist
def busqueda(item, texto=""):
logger.info("pelisalacarta.channels.verseriesynovelas busqueda")
itemlist = []
item.text_color = color2
data = scrapertools.anti_cloudflare(item.url, host=CHANNEL_HOST, headers=CHANNEL_HEADERS)
data = data.replace("\n", "").replace("\t", "")
bloque = scrapertools.find_single_match(data, '<ul class="list-paginacion">(.*?)</section>')
bloque = scrapertools.find_multiple_matches(bloque, '<li><a href=(.*?)</li>')
for match in bloque:
patron = '([^"]+)".*?<img class="fade" src="([^"]+)".*?<h2>(.*?)</h2>'
matches = scrapertools.find_multiple_matches(match, patron)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
# fix para el buscador para que no muestre entradas con texto que no es correcto
if texto.lower() not in scrapedtitle.lower():
continue
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).replace(" online", "")
if DEBUG:
logger.info("title=["+scrapedtitle+"], url=["+scrapedurl+"], thumbnail=["+scrapedthumbnail+"]")
itemlist.append(item.clone(action="episodios", title=scrapedtitle, url=scrapedurl,
thumbnail=scrapedthumbnail, fulltitle=scrapedtitle))
# Paginación
next_page = scrapertools.find_single_match(data, '<a class="nextpostslink".*?href="([^"]+)">')
if next_page != "":
itemlist.append(item.clone(title=">> Siguiente", url=next_page))
return itemlist
def mainlist(item):
logger.info("pelisalacarta.channels.tvvip mainlist")
item.viewmode = "movie"
itemlist = []
data = scrapertools.anti_cloudflare("http://tv-vip.com/json/playlist/home/index.json", host=host, headers=headers)
head = header_string + get_cookie_value()
itemlist.append(Item(channel=item.channel, title="Películas", action="submenu",
thumbnail="http://tv-vip.com/json/playlist/peliculas/thumbnail.jpg" + head,
fanart="http://tv-vip.com/json/playlist/peliculas/background.jpg" + head, viewmode="movie"))
itemlist.append(Item(channel=item.channel, title="Series", action="submenu",
thumbnail="http://tv-vip.com/json/playlist/series/poster.jpg" + head,
fanart="http://tv-vip.com/json/playlist/series/background.jpg" + head, viewmode="movie"))
itemlist.append(Item(channel=item.channel, title="Versión Original", action="entradasconlistas",
url="http://tv-vip.com/json/playlist/version-original/index.json",
thumbnail="http://tv-vip.com/json/playlist/version-original/thumbnail.jpg" + head,
fanart="http://tv-vip.com/json/playlist/version-original/background.jpg" + head, viewmode="movie_with_plot"))
itemlist.append(Item(channel=item.channel, title="Documentales", action="entradasconlistas",
url="http://tv-vip.com/json/playlist/documentales/index.json",
thumbnail="http://tv-vip.com/json/playlist/documentales/thumbnail.jpg" + head,
fanart="http://tv-vip.com/json/playlist/documentales/background.jpg" + head, viewmode="movie_with_plot"))
itemlist.append(Item(channel=item.channel, title="Películas Infantiles", action="entradasconlistas",
url="http://tv-vip.com/json/playlist/peliculas-infantiles/index.json",
thumbnail="http://tv-vip.com/json/playlist/peliculas-infantiles/thumbnail.jpg" + head,
fanart="http://tv-vip.com/json/playlist/peliculas-infantiles/background.jpg" + head, viewmode="movie_with_plot"))
itemlist.append(Item(channel=item.channel, title="Series Infantiles", action="entradasconlistas",
url="http://tv-vip.com/json/playlist/series-infantiles/index.json",
thumbnail="http://tv-vip.com/json/playlist/series-infantiles/thumbnail.jpg" + head,
fanart="http://tv-vip.com/json/playlist/series-infantiles/background.jpg" + head, viewmode="movie_with_plot"))
itemlist.append(Item(channel=item.channel, title="Buscar...", action="search",
thumbnail="http://i.imgur.com/gNHVlI4.png", fanart="http://i.imgur.com/9loVksV.png"))
return itemlist
def findvideos(item):
logger.info("pelisalacarta.channels.tvvip findvideos")
itemlist = []
# En caso de llamarse a la función desde una serie de la biblioteca
if item.extra.startswith("http"): item.url = item.extra
data = scrapertools.anti_cloudflare(item.url, host=host, headers=headers)
data = jsontools.load_json(data)
id = urllib.quote(data['id'])
for child in data["profiles"].keys():
videopath = urllib.quote(data["profiles"][child]['videoUri'])
for i in range(0, len(data["profiles"][child]['servers'])):
url = data["profiles"][child]['servers'][i]['url'] + videopath
size = " " + data["profiles"][child]["sizeHuman"]
resolution = " [" + (data["profiles"][child]['videoResolution']) + "]"
title = "Ver vídeo en " + resolution.replace('1920x1080', 'HD-1080p')
if i == 0:
title += size + " [COLOR purple]Mirror " + str(i + 1) + "[/COLOR]"
else:
title += size + " [COLOR green]Mirror " + str(i + 1) + "[/COLOR]"
# Para poner enlaces de mayor calidad al comienzo de la lista
if data["profiles"][child]["profileId"] == "default":
itemlist.insert(i, item.clone(action="play", server="directo", title=bbcode_kodi2html(title), url=url,
contentTitle=item.fulltitle, viewmode="list", extra=id, folder=False))
else:
itemlist.append(item.clone(action="play", server="directo", title=bbcode_kodi2html(title), url=url,
contentTitle=item.fulltitle, viewmode="list", extra=id, folder=False))
if len(itemlist) > 0 and item.category != "Cine" and item.category != "" and item.category != "Series":
if config.get_library_support():
itemlist.append(Item(channel=item.channel, title="Añadir enlaces a la biblioteca", text_color="green",
contentTitle=item.fulltitle, url=item.url, action="add_pelicula_to_library",
infoLabels={'title':item.fulltitle}, fulltitle=item.fulltitle))
return itemlist
def listacompleta(item):
logger.info("[cb01anime.py] listacompleta")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
patron = '<a href="#char_5a" title="Go to the letter Z">Z</a></span></div>(.*?)</ul></div><div style="clear:both;"></div></div>'
bloque = scrapertools.get_match(data, patron)
# The categories are the options for the combo
patron = '<li><a href="([^"]+)"><span class="head">([^<]+)</span></a></li>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
scrapertools.printMatches(matches)
for url, titulo in matches:
scrapedtitle = titulo
scrapedurl = url
scrapedthumbnail = ""
scrapedplot = ""
if (DEBUG): logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl + "]")
itemlist.append(
Item(channel=__channel__,
action="episodios",
fulltitle=scrapedtitle,
show=scrapedtitle,
title=scrapedtitle,
url=scrapedurl,
thumbnail="http://www.justforpastime.net/uploads/3/8/1/5/38155083/273372_orig.jpg",
plot=scrapedplot))
return itemlist
def fichas(item):
logger.info("[seriehd.py] fichas")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<h2>(.*?)</h2>\s*'
patron += '<img src="([^"]+)" alt="[^"]*" />\s*'
patron += '<A HREF="([^"]+)">'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedtitle, scrapedthumbnail, scrapedurl in matches:
scrapedthumbnail = httptools.get_url_headers(scrapedthumbnail)
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
itemlist.append(infoSod(
Item(channel=__channel__,
action="episodios",
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
fulltitle=scrapedtitle,
url=scrapedurl,
show=scrapedtitle,
thumbnail=scrapedthumbnail), tipo='tv'))
patron = "<span class='current'>\d+</span><a rel='nofollow' class='page larger' href='([^']+)'>\d+</a>"
next_page = scrapertools.find_single_match(data, patron)
if next_page != "":
itemlist.append(
Item(channel=__channel__,
action="fichas",
title="[COLOR orange]Successivo>>[/COLOR]",
url=next_page))
return itemlist
def nuoviep(item):
logger.info("streamondemand.ilgeniodellostreaming nuoviep")
itemlist = []
# Descarga la pagina
data = scrapertools.anti_cloudflare(item.url, headers)
blocco = scrapertools.get_match(data, r'<div class="items" style="margin-bottom:0px!important">(.*?)<div class="items" style="margin-bottom:0px!important">')
# Extrae las entradas (carpetas)
patron = r'<div class="poster"><img src="([^"]+)" alt="([^"]+)">[^>]+><a href="([^"]+)">'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedthumbnail, scrapedtitle, scrapedurl in matches:
scrapedplot = ""
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
if DEBUG: logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
itemlist.append(
Item(channel=__channel__,
action="episodios",
fulltitle=scrapedtitle,
show=scrapedtitle,
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot,
folder=True))
if len(itemlist) == 0:
itemlist.append(
Item(channel=__channel__,
title="[COLOR red]Nessun nuovo episodio per oggi[/COLOR]"))
return itemlist
def vistas(item):
logger.info("pelisalacarta.channels.cinetux vistas")
itemlist = []
item.text_color = color2
# Descarga la página
data = scrapertools.anti_cloudflare(item.url, headers=CHANNEL_DEFAULT_HEADERS, host=CHANNEL_HOST)
# Extrae las entradas (carpetas)
patron = '<li class="item">.*?href="([^"]+)".*?src="([^"]+)"'
patron += '.*?<h3 class="name"><a.*?>([^<]+)</a>'
matches = scrapertools.find_multiple_matches(data, patron)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
if DEBUG:
logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
new_item = item.clone(
action="findvideos",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedthumbnail,
infoLabels={},
contentTitle=scrapedtitle,
context="05",
viewmode="list",
)
itemlist.append(new_item)
# Extrae el paginador
next_page_link = scrapertools.find_single_match(data, '<a href="([^"]+)"\s+><span [^>]+>»</span>')
if next_page_link != "":
itemlist.append(item.clone(action="vistas", title=">> Página siguiente", url=next_page_link, text_color=color3))
return itemlist
def fichas(item):
logger.info("streamondemand.channels.guardaserie fichas")
itemlist = []
# data = scrapertools.cache_page(item.url)
## Descarga la página
data = re.sub(
r'\t|\n|\r',
'',
scrapertools.anti_cloudflare(item.url, headers)
)
data = scrapertools.find_single_match(data, '<a[^>]+>Serie Tv</a><ul>(.*?)</ul>')
patron = '<li><a href="([^"]+)[^>]+>([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
itemlist.append(infoSod(
Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
fulltitle=scrapedtitle,
show=scrapedtitle,
url=scrapedurl), tipo='tv'))
return itemlist
def findepisodevideo(item):
logger.info("[SerieTVU.py]==> findepisodevideo")
try:
# Download Pagina
data = scrapertools.anti_cloudflare(item.url, headers=headers)
# Prendo il blocco specifico per la stagione richiesta
patron = r'<div class="list [active]*" data-id="%s">(.*?)</div>\s*</div>' % item.extra[0][0]
blocco = scrapertools.find_single_match(data, patron)
# Estraggo l'episodio
patron = r'<a data-id="%s[^"]*" data-href="([^"]+)" data-original="([^"]+)" class="[^"]+">' % item.extra[0][1].lstrip("0")
matches = re.compile(patron, re.DOTALL).findall(blocco)
itemlist = servertools.find_video_items(data=matches[0][0])
# Non sono riuscito a trovare un modo migliore di questo, se qualcuno ha un metodo migliore di questo
# per estrarre il video lo sistemi per favore.
if len(itemlist) > 1:
itemlist.remove(itemlist[1])
server = re.sub(r'[-\[\]\s]+', '', itemlist[0].title)
itemlist[0].title = "".join(["[%s] " % color(server, 'orange'), item.title])
itemlist[0].fulltitle = item.fulltitle
itemlist[0].show = item.show
itemlist[0].thumbnail = matches[0][1]
itemlist[0].channel = __channel__
except:
import sys
for line in sys.exc_info():
logger.error("%s" % line)
return []
return itemlist
def categorias(item):
logger.info("[italiafilm.py] categorias")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
data = scrapertools.find_single_match(data, '<a href=".">Categorie</a>(.*?)</div>')
patron = '<li[^>]+><a href="([^"]+)">Film([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(data)
scrapertools.printMatches(matches)
for url, title in matches:
scrapedtitle = title
scrapedurl = urlparse.urljoin(item.url, url)
if scrapedtitle.startswith((" XXX")):
continue
scrapedplot = ""
scrapedthumbnail = ""
if DEBUG: logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
itemlist.append(
Item(channel=__channel__,
action='peliculas',
extra=item.extra,
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot,
folder=True))
return itemlist
def genere(item):
logger.info("[cb01anime.py] genere")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
bloque = scrapertools.get_match(data, '<select name="select2"(.*?)</select>')
# The categories are the options for the combo
patron = '<option value="([^"]+)">([^<]+)</option>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
scrapertools.printMatches(matches)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
if DEBUG: logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "]")
itemlist.append(
Item(channel=__channel__,
action="novita",
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=host + scrapedurl))
return itemlist
def cat(item):
logger.info("pelisalacarta.channels.tvvip cat")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, host=host, headers=headers)
data = jsontools.load_json(data)
head = header_string + get_cookie_value()
exception = ["peliculas-mas-vistas", "ultimas-peliculas"]
for child in data["sortedPlaylistChilds"]:
if child["id"] not in exception:
url = "http://tv-vip.com/json/playlist/%s/index.json" % child["id"]
# Fanart
if child['hashBackground']:
fanart = "http://tv-vip.com/json/playlist/%s/background.jpg" % child["id"]
else:
fanart = "http://tv-vip.com/json/playlist/%s/thumbnail.jpg" % child["id"]
# Thumbnail
thumbnail = "http://tv-vip.com/json/playlist/%s/thumbnail.jpg" % child["id"]
thumbnail += head
fanart += head
title = child['id'].replace('-', ' ').capitalize().replace("Manga", "Animación/Cine Oriental")
title += " ([COLOR gold]" + str(child['number']) + "[/COLOR])"
itemlist.append(
Item(channel=item.channel, action="entradasconlistas", title=bbcode_kodi2html(title), url=url,
thumbnail=thumbnail, fanart=fanart, folder=True))
return itemlist
def latestep(item):
logger.info("[SerieTVU.py]==> latestep")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<div class="item">\s*<a href="([^"]+)" data-original="([^"]+)" class="lazy inner">'
patron += r'[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)<small>([^<]+)<'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedimg, scrapedtitle, scrapedinfo in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
episodio = re.compile(r'(\d+)x(\d+)', re.DOTALL).findall(scrapedinfo)
title = "%s %s" % (scrapedtitle, scrapedinfo)
itemlist.append(infoSod(
Item(channel=__channel__,
action="findepisodevideo",
title=title,
fulltitle=scrapedtitle,
url=scrapedurl,
extra=episodio,
thumbnail=scrapedimg,
show=title,
folder=True), tipo="tv"))
return itemlist
def categorias(item):
logger.info("fusionse.laserietv categorias")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
bloque = scrapertools.get_match(data, '<ul class="dropdown-menu cat-menu">(.*?)</ul>')
# The categories are the options for the combo
patron = '<li ><a href="([^"]+)">(.*?)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
for scrapedurl, scrapedtitle in matches:
scrapedurl = urlparse.urljoin(item.url, scrapedurl)
scrapedthumbnail = ""
scrapedplot = ""
if (DEBUG): logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
itemlist.append(
Item(channel=__channel__,
action="lista_serie",
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot))
return itemlist
def menuanyos(item):
logger.info("[cineblog01.py] menuvk")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
bloque = scrapertools.get_match(data, '<select name="select3"(.*?)</select>')
# The categories are the options for the combo
patron = '<option value="([^"]+)">([^<]+)</option>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
scrapertools.printMatches(matches)
for url, titulo in matches:
scrapedtitle = titulo
scrapedurl = urlparse.urljoin(item.url, url)
scrapedthumbnail = ""
scrapedplot = ""
if (DEBUG): logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
itemlist.append(
Item(channel=__channel__,
action="peliculas",
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
extra=item.extra,
plot=scrapedplot))
return itemlist
def categorias(item):
logger.info("streamondemand.altadefinizione01 categorias")
itemlist = []
# data = scrapertools.cache_page(item.url)
data = scrapertools.anti_cloudflare(item.url, headers)
# Narrow search by selecting only the combo
bloque = scrapertools.get_match(data, '<ul class="kategori_list">(.*?)</ul>')
# The categories are the options for the combo
patron = '<li><a href=\'([^\']+)\'>([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(bloque)
for url, titulo in matches:
scrapedtitle = titulo
scrapedurl = urlparse.urljoin(item.url, url)
scrapedthumbnail = ""
scrapedplot = ""
if DEBUG: logger.info(
"title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
itemlist.append(
Item(channel=__channel__,
action="peliculas",
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot))
return itemlist
def peliculas_tv(item):
logger.info("streamondemand-pureita.casacinema peliculas_tv")
itemlist = []
# Descarga la pagina
data = scrapertools.anti_cloudflare(item.url, headers)
# Extrae las entradas (carpetas)
patron = '<li><a href="([^"]+)"[^=]+="([^"]+)"><div>\s*<div[^>]+>(.*?)<'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
title = scrapertools.decodeHtmlentities(scrapedtitle)
scrapedplot = ""
itemlist.append(
infoSod(Item(channel=__channel__,
action="episodios",
title=title,
url=scrapedurl,
thumbnail=scrapedthumbnail,
fulltitle=title,
show=title,
plot=scrapedplot,
extra=item.extra,
folder=True),
tipo='tv'))
## Paginación
next_page = scrapertools.find_single_match(
data, '<li><a href="([^"]+)" >Pagina')
if next_page != "":
itemlist.append(
Item(
channel=__channel__,
action="peliculas_tv",
title="[COLOR orange]Successivi >>[/COLOR]",
url=next_page,
extra=item.extra,
thumbnail=
"https://raw.githubusercontent.com/orione7/Pelis_images/master/channels_icon_pureita/next_1.png"
))
return itemlist
def findvideos(item):
logger.info("[hdgratis.py] findvideos")
# Descarga la página
data = scrapertools.anti_cloudflare(item.url, headers).replace('\n', '')
patron = r'<iframe width=".+?" height=".+?" src="([^"]+)"></iframe>'
url = scrapertools.find_single_match(data, patron).replace("?alta", "")
url = url.replace("&download=1", "")
if 'hdpass' in url:
data = scrapertools.cache_page(url, headers=headers)
start = data.find('<div class="row mobileRes">')
end = data.find('<div id="playerFront">', start)
data = data[start:end]
patron_res = '<div class="row mobileRes">(.*?)</div>'
patron_mir = '<div class="row mobileMirrs">(.*?)</div>'
patron_media = r'<input type="hidden" name="urlEmbed" data-mirror="([^"]+)" id="urlEmbed" value="([^"]+)"/>'
res = scrapertools.find_single_match(data, patron_res)
urls = []
for res_url, res_video in scrapertools.find_multiple_matches(res, '<option.*?value="([^"]+?)">([^<]+?)</option>'):
data = scrapertools.cache_page(urlparse.urljoin(url, res_url), headers=headers).replace('\n', '')
mir = scrapertools.find_single_match(data, patron_mir)
for mir_url in scrapertools.find_multiple_matches(mir, '<option.*?value="([^"]+?)">[^<]+?</value>'):
data = scrapertools.cache_page(urlparse.urljoin(url, mir_url), headers=headers).replace('\n', '')
for media_label, media_url in re.compile(patron_media).findall(data):
urls.append(url_decode(media_url))
itemlist = servertools.find_video_items(data='\n'.join(urls))
for videoitem in itemlist:
videoitem.title = item.title + videoitem.title
videoitem.fulltitle = item.fulltitle
videoitem.thumbnail = item.thumbnail
videoitem.show = item.show
videoitem.plot = item.plot
videoitem.channel = __channel__
return itemlist
def film(item):
logger.info("[thegroove360.guardogratis] film")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = '<div data-movie-id=".*?" class="ml-item">\s*<a href="([^"]+)" data-url="" class="ml-mask jt" data-hasqtip=".*?" oldtitle=".*?" title="">.*?'
patron += '<img data-original="([^"]+)" class="lazy thumb mli-thumb" alt="([^<]+)">.*?'
patron += '<div class="jt-info.*?">\s*([^<]+)</.*?<p class="f-desc">(.*?)<\/p>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedimg, scrapedtitle, rating, scrapedplot in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
if rating:
rating = " ([COLOR yellow]" + rating + "[/COLOR])"
scrapedtitle=scrapedtitle.replace("[", "(").replace("]", ")")
scrapedplot = scrapedplot.replace("<p>", "")
itemlist.append(infoSod(
Item(channel=__channel__,
action="episodios" if "series" in scrapedurl else "findvideos",
contentType="tv" if "series" in scrapedurl else "movie",
title=scrapedtitle + rating,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedimg,
plot=scrapedplot,
show=scrapedtitle,
extra=item.extra,
folder=True), tipo="tv" if "series" in scrapedurl else "movie"))
patron = "<li class='active'><a class=''>\d+</a></li><li><a rel='nofollow' class='page larger' href='([^']+)'>\d+</a>"
matches = re.compile(patron, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="film",
title="[COLOR orange]Successivi >>[/COLOR]",
url=scrapedurl,
thumbnail="https://raw.githubusercontent.com/stesev1/channels/master/images/channels_icon/next_1.png",
folder=True))
return itemlist
def lista_anime(item):
logger.info("[AnimeSenzaLimiti.py]==> lista_anime")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<a href="([^"]+)"><img.*?src="([^?]+)[^"]+".*?/>'
patron += r'[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)</a>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
scrapedtitle = removestreaming(scrapedtitle)
itemlist.append(
infoSod(Item(channel=__channel__,
action="episodi",
contentType="tv",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
extra="tv",
thumbnail=scrapedthumbnail,
folder=True),
tipo="tv"))
patronvideos = r'<a class="next page-numbers" href="([^"]+)">'
matches = re.compile(patronvideos, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="HomePage",
title=color("Torna Home", "yellow"),
folder=True)),
itemlist.append(
Item(
channel=__channel__,
action="lista_anime",
title=color("Successivo >>", "orange"),
url=scrapedurl,
thumbnail=
"http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
folder=True))
return itemlist
def episodios(item):
logger.info("streamondemand-pureita.channels.altastreaming episodios")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<li id="serie-[^-]+-title="([^"]+)">\s*<span[^<]+<\/span>\s*<span[^<]+<\/span>\s*<a[^=]+=[^=]+=[^=]+=[^=]+=[^=]+="([^"]+)">'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedtitle, scrapedurl in matches:
scrapedplot = ""
scrapedthumbnail = ""
scrapedtitle = scrapedtitle.replace('Stai guardando: ', '')
itemlist.append(
infoSod(Item(channel=__channel__,
action="findvideos",
fulltitle=scrapedtitle,
show=scrapedtitle,
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
contentType="episode",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot,
folder=True),
tipo='tv'))
if config.get_library_support() and len(itemlist) != 0:
itemlist.append(
Item(channel=__channel__,
title="Aggiungi alla libreria",
url=item.url,
action="add_serie_to_library",
extra="episodios",
show=item.show))
itemlist.append(
Item(channel=__channel__,
title="Scarica tutti gli episodi della serie",
url=item.url,
action="download_all_episodes",
extra="episodios",
show=item.show))
return itemlist
def peliculas(item):
logger.info("pureita.altadefinizione01 peliculas")
itemlist = []
# Descarga la pagina
data = scrapertools.anti_cloudflare(item.url, headers)
# Extrae las entradas (carpetas)
patron = '<div class="short_content">\s*<a href="([^"]+)">\s*'
patron += '<img src="([^"]+)" alt="[^"]+" class="shortstory-img" />\s*<div class="short_header">\s*([^<]+)</div>'
matches = re.compile(patron, re.DOTALL).finditer(data)
for match in matches:
scrapedplot = ""
scrapedthumbnail = urlparse.urljoin(item.url, match.group(2))
scrapedtitle = scrapertools.unescape(match.group(3))
scrapedurl = urlparse.urljoin(item.url, match.group(1))
if DEBUG: logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl + "]")
itemlist.append(infoSod(
Item(channel=__channel__,
action="findvideos",
contentType="movie",
fulltitle=scrapedtitle,
show=scrapedtitle,
title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
url=scrapedurl,
thumbnail=scrapedthumbnail,
plot=scrapedplot,
folder=True), tipo='movie'))
# Extrae el paginador
patronvideos = '<a\s*href="([^"]+)">></a>'
matches = re.compile(patronvideos, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = urlparse.urljoin(item.url, matches[0])
itemlist.append(
Item(channel=__channel__,
action="peliculas",
title="[COLOR orange]Successivo >>[/COLOR]",
url=scrapedurl,
thumbnail="https://raw.githubusercontent.com/orione7/Pelis_images/master/channels_icon_pureita/next_1.png",
folder=True))
return itemlist
def episodios(item):
logger.info("[SerieTVU.py]==> episodios")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<option value="(\d+)"[\sselected]*>.*?</option>'
matches = re.compile(patron, re.DOTALL).findall(data)
for value in matches:
patron = r'<div class="list [active]*" data-id="%s">(.*?)</div>\s*</div>' % value
blocco = scrapertools.find_single_match(data, patron)
patron = r'(<a data-id="\d+[^"]*" data-href="([^"]+)" data-original="([^"]+)" class="[^"]+">)[^>]+>[^>]+>([^<]+)</div>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedextra, scrapedurl, scrapedimg, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(
scrapedtitle.replace("Episodio", "")).strip()
itemlist.append(
Item(channel=__channel__,
action="findvideos",
title=value + "x" + scrapedtitle.zfill(2),
fulltitle=scrapedtitle,
contentType="episode",
url=scrapedurl,
thumbnail=scrapedimg,
extra=scrapedextra,
folder=True))
if config.get_library_support() and len(itemlist) != 0:
itemlist.append(
Item(channel=__channel__,
title="Aggiungi alla libreria",
url=item.url,
action="add_serie_to_library",
extra="episodios",
show=item.show))
itemlist.append(
Item(channel=__channel__,
title="Scarica tutti gli episodi della serie",
url=item.url,
action="download_all_episodes",
extra="episodios",
show=item.show))
return itemlist
def film_new(item):
logger.info("[thegroove360.guardogratis] film")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
blocco = scrapertools.get_match(data, 'Ultimi Film<i class="fa fa-chevron-right ml10">(.*?)Ultime Serie TV <i class="fa fa-chevron-right ml10">')
patron = '<div data-movie-id=".*?" class="ml-item">\s*<a href="([^"]+)" data-url="" class="ml-mask jt" data-hasqtip=".*?" oldtitle=".*?" title="">.*?'
patron += '<img data-original="([^"]+)" class="lazy thumb mli-thumb" alt="([^<]+)">.*?'
patron += '<div class="jt-info.*?">\s*([^<]+)</.*?<p class="f-desc">(.*?)<\/p>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedurl, scrapedimg, scrapedtitle, rating, scrapedplot in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
if rating:
rating = " ([COLOR yellow]" + rating + "[/COLOR])"
scrapedtitle=scrapedtitle.replace("[", "(").replace("]", ")")
scrapedplot = scrapedplot.replace("<p>", "")
itemlist.append(infoSod(
Item(channel=__channel__,
action="findvideos",
title=scrapedtitle + rating,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedimg,
plot=scrapedplot,
extra=item.extra,
folder=True), tipo="movie"))
patron = '<link rel="next" href="([^"]+)" />'
matches = re.compile(patron, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="film_new",
title="[COLOR orange]Successivo >>[/COLOR]",
url=scrapedurl,
thumbnail="https://raw.githubusercontent.com/stesev1/channels/master/images/channels_icon/next_1.png",
folder=True))
return itemlist
def episodios(item):
logger.info("streamondemand.casacinema episodios")
itemlist = []
# Downloads page
data = scrapertools.anti_cloudflare(item.url, headers)
# Extracts the entries
patron = '(.*?)<a href="(.*?)" target="_blank" rel="nofollow".*?>(.*?)</a>'
matches = re.compile(patron).findall(data)
for scrapedtitle, scrapedurl, scrapedserver in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
if scrapedtitle.startswith("<p>"):
scrapedtitle = scrapedtitle[3:]
itemlist.append(
Item(channel=__channel__,
action="findvideos",
title="[COLOR red]" + scrapedtitle + " [/COLOR]" +
"[COLOR azure]" + item.fulltitle + " [/COLOR]" +
"[COLOR orange] [" + scrapedserver + "][/COLOR]",
url=scrapedurl,
thumbnail=item.thumbnail,
fulltitle=item.show + ' | ' + scrapedtitle,
extra=item.extra,
show=item.show))
if config.get_library_support() and len(itemlist) != 0:
itemlist.append(
Item(channel=__channel__,
title=item.title,
url=item.url,
action="add_serie_to_library",
extra="episodios" + "###" + item.extra,
show=item.show))
itemlist.append(
Item(channel=item.channel,
title="Scarica tutti gli episodi della serie",
url=item.url,
action="download_all_episodes",
extra="episodios" + "###" + item.extra,
show=item.show))
return itemlist
def perlettere(item):
logger.info("[BleachAnimeManga.py]==> perlettere")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<option value="(\d+)">-\s* (\.?[A-Z\-1-9]+)</option>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedid, scrapedtitle in matches:
itemlist.append(
Item(channel=__channel__,
action="lista_anime",
title=scrapedtitle,
url="%s/?f=%s&st=0" % (host, scrapedid),
folder=True))
return itemlist
def play(item):
logger.info("pelisalacarta.channels.seriesblanco play url={0}".format(item.url))
if item.url.startswith(HOST):
data = scrapertools.anti_cloudflare(item.url, headers=CHANNEL_HEADERS, host=CHANNEL_HOST)
patron = "<input type='button' value='Ver o Descargar' onclick='window.open\(\"([^\"]+)\"\);'/>"
url = scrapertools.find_single_match(data, patron)
else:
url = item.url
itemlist = servertools.find_video_items(data=url)
for videoitem in itemlist:
videoitem.title = item.title
videoitem.channel = item.channel
return itemlist
def list_a_z(item):
logger.info("[vediserie.py] ordine alfabetico")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers)
patron = '<li><a href="([^"]+)" title="([^"]+)">.*?</a></li>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedtitle in matches:
itemlist.append(
Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
url=scrapedurl))
return itemlist
def findvideos(item):
logger.info("[altadefinizione01.py] findvideos")
# Descarga la página
data = scrapertools.anti_cloudflare(item.url, headers)
itemlist = servertools.find_video_items(data=data)
for videoitem in itemlist:
videoitem.title = "".join([
item.title, '[COLOR green][B]' + videoitem.title + '[/B][/COLOR]'
])
videoitem.fulltitle = item.fulltitle
videoitem.show = item.show
videoitem.thumbnail = item.thumbnail
videoitem.channel = __channel__
return itemlist
def peliculas(item):
logger.info("[ItaliaFilm01.py]==> peliculas")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<div class="(?:film-item|item-film)">\s*(?:[^>]+>\s*|)<a href="([^"]+)".*?>\s*'
patron += r'(?:<div class="item\-film\-img">\s*|)<img src="([^"]+)" alt="([^"]+)">'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
scrapedtitle = re.sub(r'(?:C|c)over', '', scrapedtitle).strip()
itemlist.append(infoSod(
Item(channel=__channel__,
action="findvideos",
contentType="movie",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
extra="movie",
thumbnail=scrapedthumbnail,
folder=True), tipo="movie"))
# Pagine
patron = r'<a href="([^"]+)" rel="next">'
matches = re.compile(patron, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="HomePage",
title="[COLOR yellow]Torna Home[/COLOR]",
folder=True)),
itemlist.append(
Item(channel=__channel__,
action="peliculas",
title="[COLOR orange]Successivo >>[/COLOR]",
url=scrapedurl,
thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
extra=item.extra,
folder=True))
return itemlist
def film(item):
logger.info("[AltadefinizioneHD.py]==> film")
itemlist = []
item.url = urllib.unquote_plus(item.url).replace("\\", "")
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = '<a href="([^"]+)">[^>]+>\s<img src="([^"]+)" alt="([^"]+)" />'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedimg, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
itemlist.append(
infoSod(Item(channel=__channel__,
action="findvideos",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedimg,
extra=item.extra,
folder=True),
tipo=item.extra))
patron = "<a rel='nofollow' class=previouspostslink' href='([^']+)'>Successiva.*?</a>"
matches = re.compile(patron, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="HomePage",
title=color("Torna Home", "yellow"),
folder=True))
itemlist.append(
Item(
channel=__channel__,
action="film",
title=color("Successivo >>", "orange"),
url=scrapedurl,
thumbnail=
"http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
folder=True))
return itemlist
def episodios(item):
logger.info("pelisalacarta.channels.verseriesynovelas episodios")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, host=CHANNEL_HOST, headers=CHANNEL_HEADERS)
data = data.replace("\n", "").replace("\t", "")
plot = scrapertools.find_single_match(data, '<p><p>(.*?)</p>')
item.plot = scrapertools.htmlclean(plot)
bloque = scrapertools.find_multiple_matches(data, '<td data-th="Temporada"(.*?)</div>')
for match in bloque:
matches = scrapertools.find_multiple_matches(match, '.*?href="([^"]+)".*?title="([^"]+)"')
for scrapedurl, scrapedtitle in matches:
season, episode = scrapertools.find_single_match(scrapedtitle, '(\d+)(?:×|x)(\d+)')
item.infoLabels['season'] = season
item.infoLabels['episode'] = episode
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle) + " "
scrapedtitle = scrapedtitle.replace('Temporada', '')
if "ES.png" in match:
scrapedtitle += "[CAST]"
if "SUB.png" in match:
scrapedtitle += "[VOSE]"
if "LA.png" in match:
scrapedtitle += "[LAT]"
if "EN.png" in match:
scrapedtitle += "[V.O]"
if (DEBUG): logger.info("title=["+scrapedtitle+"], url=["+scrapedurl+"]")
itemlist.append(item.clone(action="findvideos", title=scrapedtitle, url=scrapedurl))
itemlist.reverse()
if itemlist and item.extra != "episodios":
try:
from core import tmdb
tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
except:
pass
itemlist.append(item.clone(channel="trailertools", title="Buscar Tráiler", action="buscartrailer", context="",
text_color="magenta"))
if item.category != "" and config.get_library_support():
itemlist.append(Item(channel=item.channel, title="Añadir esta temporada a la biblioteca", url=item.url,
action="add_serie_to_library", extra="episodios", text_color="green", show=item.show))
return itemlist
def episodios(item):
logger.info("[cb01anime.py] episodios")
itemlist = []
# Descarga la página
data = scrapertools.anti_cloudflare(item.url, headers)
data = scrapertools.decodeHtmlentities(data)
patron1 = '(?:<p>|<td bgcolor="#ECEAE1">)<span class="txt_dow">(.*?)(?:</p>)?(?:\s*</span>)?\s*</td>'
patron2 = '<a.*?href="([^"]+)"[^>]*>([^<]+)</a>'
matches1 = re.compile(patron1, re.DOTALL).findall(data)
if len(matches1) > 0:
for match1 in re.split('<br />|<p>', matches1[0]):
if len(match1) > 0:
# Extrae las entradas
titulo = None
scrapedurl = ''
matches2 = re.compile(patron2, re.DOTALL).finditer(match1)
for match2 in matches2:
if titulo is None:
titulo = match2.group(2)
scrapedurl += match2.group(1) + '#' + match2.group(2) + '|'
if titulo is not None:
title = item.title + " " + titulo
itemlist.append(
Item(channel=__channel__,
action="findvideos",
contentType="episode",
title=title,
extra=scrapedurl,
fulltitle=item.fulltitle,
show=item.show))
if config.get_library_support() and len(itemlist) != 0:
itemlist.append(
Item(channel=__channel__,
title="Aggiungi alla libreria",
url=item.url,
action="add_serie_to_library",
extra="episodios",
show=item.show))
return itemlist
def lista_anime(item):
logger.info("[Majintoon.py]==> lista_anime")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<figure class="post-image">\s*<a title="([^"]+)" href="([^"]+)">'
patron += r'\s*<img.*?src="([^"]*)".*?/>\s*</a>\s*</figure>'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedtitle, scrapedurl, scrapedthumbnail in matches:
title = scrapertools.decodeHtmlentities(scrapedtitle)
itemlist.append(infoSod(
Item(channel=__channel__,
action="episodi",
contentType="tv",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
show=scrapedtitle,
extra="tv",
thumbnail=scrapedthumbnail,
folder=True), tipo="tv"))
# Pagine
patron = '<div class="nav-previous"><a href="([^"]+)" >'
matches = re.compile(patron, re.DOTALL).findall(data)
if len(matches) > 0:
scrapedurl = matches[0]
itemlist.append(
Item(channel=__channel__,
action="HomePage",
title=color("Torna Home", "yellow"),
folder=True)),
itemlist.append(
Item(channel=__channel__,
action="lista_anime",
title=color("Successivo >>", "orange"),
url=scrapedurl,
thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
folder=True))
return itemlist
def search(item, texto):
logger.info("[pelisalacarta.seriesblanco search texto={0}".format(texto))
itemlist = []
if texto != "":
item.url = urlparse.urljoin(HOST, "/search.php?q1={0}".format(texto))
data = scrapertools.anti_cloudflare(item.url, headers=CHANNEL_HEADERS, host=CHANNEL_HOST)
data = re.sub(r"\n|\r|\t|\s{2}| |<Br>|<BR>|<br>|<br/>|<br />|-\s", "", data)
data = re.sub(r"<!--.*?-->", "", data)
data = unicode(data, "iso-8859-1", errors="replace").encode("utf-8")
'''
<div style='float:left;width: 33%;text-align:center;'>
<a href='/serie/2561/acacias-38.html' '>
<img class='ict' src='http://seriesblanco.com/files/uploads/2561.jpg' alt='Capitulos de: Acacias 38'
height='184' width='120'>
</a>
<div style='text-align:center;line-height:20px;height:20px;'>
<a href='/serie/2561/acacias-38.html' style='font-size: 11px;'> Acacias 38</a>
</div>
</div>
'''
patron = "<img class='ict' src='([^']+)'[^>]+></a>" \
"<div style='text-align:center;line-height:20px;height:20px;'>" \
"<a href='([^']+)' style='font-size: 11px;'>([^<]+)</a>"
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedthumb, scrapedurl, scrapedtitle in matches:
itemlist.append(Item(channel=item.channel, title=scrapedtitle.strip(), url=urlparse.urljoin(HOST, scrapedurl),
action="episodios", show=scrapedtitle.strip(), thumbnail=scrapedthumb,
list_idiomas=list_idiomas, list_calidad=CALIDADES, context=CONTEXT))
try:
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 findvideos(item):
logger.info("[OcchioDelWrestling.py]==> findvideos")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<a href="(http://adf.ly/[^"]+)"(?: target="_blank"|)>(.*?)</a>'
matches = re.compile(patron, re.DOTALL).findall(data)
index = 1
for scrapedurl, scrapedtitle in matches:
itemlist.append(
Item(channel=__channel__,
action="play",
title="Link %s: %s" % (index, scrapedtitle),
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=item.thumbnail))
index += 1
return itemlist
def findvideos(item):
itemlist = []
item.url = item.url.replace(".tv", ".co")
data = scrapertools.anti_cloudflare(item.url, headers)
elemento = scrapertools.find_single_match(data, 'file: "(.*?)",')
itemlist.append(
Item(channel=__channel__,
action="play",
title=item.title,
url=elemento,
thumbnail=item.thumbnail,
fanart=item.fanart,
fulltitle=item.fulltitle,
show=item.fulltitle))
return itemlist
def indices(item):
logger.info("pelisalacarta.channels.verseriesynovelas indices")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, host=CHANNEL_HOST, headers=CHANNEL_HEADERS)
data = data.replace("\n", "").replace("\t", "")
if "Categorías" in item.title:
bloque = scrapertools.find_single_match(data, '<span>Seleccion tu categoria</span>(.*?)</section>')
matches = scrapertools.find_multiple_matches(bloque, '<li.*?<a href="([^"]+)">(.*?)</a>')
for url, title in matches:
itemlist.append(item.clone(action="ultimas", title=title, url=url))
else:
bloque = scrapertools.find_single_match(data, '<ul class="alfabetico">(.*?)</ul>')
matches = scrapertools.find_multiple_matches(bloque, '<li.*?<a href="([^"]+)".*?>(.*?)</a>')
for url, title in matches:
itemlist.append(item.clone(action="ultimas", title=title, url=url))
return itemlist
def findvideos(item):
data = scrapertools.anti_cloudflare(item.url, headers)
itemlist = servertools.find_video_items(data=data)
for videoitem in itemlist:
servername = re.sub(r'[-\[\]\s]+', '', videoitem.title)
videoitem.title = "".join([
'[[COLOR orange]' + servername.capitalize() + '[/COLOR]] - ',
item.title
])
videoitem.fulltitle = item.fulltitle
videoitem.show = item.show
videoitem.thumbnail = item.thumbnail
videoitem.plot = item.plot
videoitem.channel = __channel__
return itemlist
def episodi(item):
logger.info("[GuardaSerieOnline.py]==> episodi")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<img\s*.*?[meta-src|data-original]*="([^"]+)"\s*/>[^>]+>([^<]+)<[^>]+>[^>]+>[^>]+>'
patron += r'[^>]+>[^>]+>([^<]+)*<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>'
patron += r'[^>]+>[^>]+>[^>]+>\s*<span\s*.*?(meta-embed="[^"]+">)'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedthumbnail, scrapedep, scrapedeptitle, scrapedextra in matches:
scrapedeptitle = scrapertools.decodeHtmlentities(
scrapedeptitle).strip()
scrapedep = scrapertools.decodeHtmlentities(scrapedep).strip()
scrapedtitle = "%s - %s" % (
scrapedep, scrapedeptitle) if scrapedeptitle != "" else scrapedep
itemlist.append(
Item(channel=__channel__,
action="findvideos",
title=scrapedtitle,
fulltitle=scrapedtitle,
url="",
contentType="episode",
extra=scrapedextra,
thumbnail=scrapedthumbnail,
folder=True))
if config.get_library_support() and len(itemlist) != 0:
itemlist.append(
Item(channel=__channel__,
title="Aggiungi alla libreria",
url=item.url,
action="add_serie_to_library",
extra="episodi",
show=item.show))
itemlist.append(
Item(channel=__channel__,
title="Scarica tutti gli episodi della serie",
url=item.url,
action="download_all_episodes",
extra="episodi",
show=item.show))
return itemlist
def findvid(item):
logger.info("streamondemand.italiafilm findvid")
itemlist = []
# Descarga la página
data = scrapertools.anti_cloudflare(item.url, headers)
# Extrae las entradas
patron = '<iframe style="border: 0;" src="([^"]+)" width="[^"]*" height="[^"]*" scrolling="[^"]*" allowfullscreen="[^"]*">'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl in matches:
data += scrapertools.cache_page(scrapedurl, headers=headers)
### robalo fix obfuscator - start ####
patron = 'href="(https?://www\.keeplinks\.eu/p16/([^"]+))"'
matches = re.compile(patron, re.DOTALL).findall(data)
for keeplinks, id in matches:
headers.append([
'Cookie', 'flag[' + id + ']=1; defaults=1; nopopatall=' +
str(int(time.time()))
])
headers.append(['Referer', keeplinks])
html = scrapertools.cache_page(keeplinks, headers=headers)
data += str(
scrapertools.find_multiple_matches(
html, '<a href="([^"]+)" target="_blank"'))
### robalo fix obfuscator - end ####
for videoitem in servertools.find_video_items(data=data):
videoitem.title = item.title + videoitem.title
videoitem.fulltitle = item.fulltitle
videoitem.thumbnail = item.thumbnail
videoitem.show = item.show
videoitem.plot = item.plot
videoitem.channel = __channel__
itemlist.append(videoitem)
return itemlist
def vistas(item):
logger.info("pelisalacarta.channels.cinetux vistas")
itemlist = []
item.text_color = color2
# Descarga la página
data = scrapertools.anti_cloudflare(item.url,
headers=CHANNEL_DEFAULT_HEADERS,
host=CHANNEL_HOST)
# Extrae las entradas (carpetas)
patron = '<li class="item">.*?href="([^"]+)".*?src="([^"]+)"'
patron += '.*?<h3 class="name"><a.*?>([^<]+)</a>'
matches = scrapertools.find_multiple_matches(data, patron)
for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
if (DEBUG):
logger.info("title=[" + scrapedtitle + "], url=[" + scrapedurl +
"], thumbnail=[" + scrapedthumbnail + "]")
new_item = item.clone(action="findvideos",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedthumbnail,
infoLabels={},
contentTitle=scrapedtitle,
context=["buscar_trailer"],
viewmode="list",
contentType="movie")
itemlist.append(new_item)
# Extrae el paginador
next_page_link = scrapertools.find_single_match(
data, '<a href="([^"]+)"\s+><span [^>]+>»</span>')
if next_page_link != "":
itemlist.append(
item.clone(action="vistas",
title=">> Página siguiente",
url=next_page_link,
text_color=color3))
return itemlist
def lista_serie(item):
logger.info("[SerieTVU.py]==> lista_serie")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
patron = r'<div class="item">\s*<a href="([^"]+)" data-original="([^"]+)" class="lazy inner">'
patron += r'[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)<'
matches = re.compile(patron, re.DOTALL).findall(data)
for scrapedurl, scrapedimg, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
itemlist.append(
infoSod(Item(channel=__channel__,
action="episodios",
title=scrapedtitle,
fulltitle=scrapedtitle,
url=scrapedurl,
thumbnail=scrapedimg,
show=scrapedtitle,
folder=True),
tipo="tv"))
# Pagine
patron = r'<li><a href="([^"]+)"\s*>Pagina'
next_page = scrapertools.find_single_match(data, patron)
if len(matches) > 0:
itemlist.append(
Item(channel=__channel__,
action="HomePage",
title="[COLOR yellow]Torna Home[/COLOR]",
folder=True)),
itemlist.append(
Item(
channel=__channel__,
action="lista_serie",
title="[COLOR orange]Successivo >>[/COLOR]",
url=next_page,
thumbnail=
"http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
folder=True))
return itemlist
def categorie(item):
logger.info("[Cineblog01Blog.py]==> categorie")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
blocco = scrapertools.get_match(data,
r'<ul>\s*<li class="drop">(.*?)</ul>')
patron = r'<li><a href="([^"]+)">([^"]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedurl, scrapedtitle in matches:
scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
itemlist.append(
Item(channel=__channel__,
action="peliculas",
title=scrapedtitle,
url="".join([host, scrapedurl]),
folder=True))
return itemlist
def categorie(item):
logger.info("[Majintoon.py]==> categorie")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
blocco = scrapertools.get_match(data, r'Categorie</a>\s*<ul class="sub-menu">(.*?)</ul>\s*</li>')
patron = r'<li[^>]+><a href="([^"]+)">([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedurl, scrapedtitle in matches:
itemlist.append(
Item(channel=__channel__,
action="lista_anime",
title=scrapedtitle,
url=scrapedurl,
extra="tv",
thumbnail=item.thumbnail,
folder=True))
return itemlist
def categorie(item):
logger.info("[SerieTVU.py]==> categorie")
itemlist = []
data = scrapertools.anti_cloudflare(item.url, headers=headers)
blocco = scrapertools.get_match(data, '<h2>Sfoglia</h2>\s*<ul>(.*?)</ul>\s*</section>')
patron = '<li><a href="([^"]+)">([^<]+)</a></li>'
matches = re.compile(patron, re.DOTALL).findall(blocco)
for scrapedurl, scrapedtitle in matches:
itemlist.append(
Item(channel=__channel__,
action="lista_serie",
title=scrapedtitle,
contentType="tv",
url="%s%s" % (host, scrapedurl),
thumbnail=item.thumbnail,
folder=True))
return itemlist
