From 82feca4ca22b43b09945dca3c975bbc5f5f3a09c Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Mon, 15 Apr 2019 22:41:50 +0200
Subject: [PATCH 01/23] Vedohd small fixes

---
 plugin.video.alfa/channels/vedohd.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/plugin.video.alfa/channels/vedohd.py b/plugin.video.alfa/channels/vedohd.py
index 71e3c5ba..4850640c 100644
--- a/plugin.video.alfa/channels/vedohd.py
+++ b/plugin.video.alfa/channels/vedohd.py
@@ -101,12 +101,14 @@ def findvideos(item):
 
 
 def generos(item):
+    findhost()
     patron = '<a href="([^"#]+)">([a-zA-Z]+)'
     return support.scrape(item, patron, ['url', 'title'], patron_block='<a href="#">Genere</a><ul class="sub-menu">.*?</ul>', action='peliculas', url_host=host)
 
 
 def year(item):
-    patron = '<a href="([^"#]+)">([a-zA-Z]+)'
+    findhost()
+    patron = r'<a href="([^"#]+)">(\d+)'
     return support.scrape(item, patron, ['url', 'title'], patron_block='<a href="#">Anno</a><ul class="sub-menu">.*?</ul>', action='peliculas', url_host=host)
 
 

From 3b51f610d0ded221e848f63d2027e99a08ccf04a Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Mon, 15 Apr 2019 22:42:35 +0200
Subject: [PATCH 02/23] Italiaserie updated and enabled

---
 plugin.video.alfa/channels/italiaserie.json |   2 +-
 plugin.video.alfa/channels/italiaserie.py   | 311 +++++---------------
 2 files changed, 81 insertions(+), 232 deletions(-)

diff --git a/plugin.video.alfa/channels/italiaserie.json b/plugin.video.alfa/channels/italiaserie.json
index ce9d7686..ba094b25 100644
--- a/plugin.video.alfa/channels/italiaserie.json
+++ b/plugin.video.alfa/channels/italiaserie.json
@@ -1,7 +1,7 @@
 {
     "id": "italiaserie",
     "name": "Italia Serie",
-    "active": false,
+    "active": true,
     "adult": false,
     "language": ["ita"],
     "thumbnail": "https:\/\/raw.githubusercontent.com\/Zanzibar82\/images\/master\/posters\/italiaserie.png",
diff --git a/plugin.video.alfa/channels/italiaserie.py b/plugin.video.alfa/channels/italiaserie.py
index 073f522a..2e0ae31e 100644
--- a/plugin.video.alfa/channels/italiaserie.py
+++ b/plugin.video.alfa/channels/italiaserie.py
@@ -4,34 +4,36 @@
 # Canale per italiaserie
 # ----------------------------------------------------------
 import re
-import urlparse
 
-from core import httptools, scrapertools, servertools
-from core.item import Item
+import autoplay
+import filtertools
+import support
+from core import httptools, scrapertools
 from core import tmdb
-from lib import unshortenit
-from platformcode import config, logger
+from core.item import Item
+from platformcode import logger
 
 host = "https://italiaserie.org"
 
+list_servers = ['speedvideo']
+list_quality = ['1080p', '720p', '480p']
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+
 
 def mainlist(item):
-    logger.info("kod.italiaserie mainlist")
-    itemlist = [Item(channel=item.channel,
-                     title="[COLOR azure]Aggiornamenti Serie TV[/COLOR]",
-                     action="peliculas",
-                     url=host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     title="[COLOR azure]Ultimi Episodi[/COLOR]",
-                     action="latestep",
-                     url="%s/aggiornamento-episodi/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     title="[COLOR yellow]Cerca...[/COLOR]",
-                     action="search",
-                     extra="tvshow",
-                     thumbnail="http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")]
+    support.log()
+    itemlist = []
+
+    support.menu(itemlist, 'Ultime Uscite', 'peliculas', host + "/category/serie-tv/", "episode")
+    support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host + "/ultimi-episodi/", "episode", 'latest')
+    support.menu(itemlist, 'Categorie', 'menu', host, "episode", args="Serie-Tv per Genere")
+    support.menu(itemlist, 'Cerca...', 'search', host, 'episode', args='serie')
+
+    autoplay.init(item.channel, list_servers, list_quality)
+    autoplay.show_option(item.channel, itemlist)
+
     return itemlist
 
 
@@ -41,11 +43,13 @@ def newest(categoria):
     item = Item()
     try:
         if categoria == "series":
-            item.url = "%s/aggiornamento-episodi/" % host
-            item.action = "latestep"
-            itemlist = latestep(item)
+            item.url = host + "/ultimi-episodi/"
+            item.action = "peliculas"
+            item.args = "latest"
+            item.contentType = "episode"
+            itemlist = peliculas(item)
 
-            if itemlist[-1].action == "latestep":
+            if itemlist[-1].action == "peliculas":
                 itemlist.pop()
 
     # Continua la ricerca in caso di errore 
@@ -58,107 +62,38 @@ def newest(categoria):
     return itemlist
 
 
-def latestep(item):
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    blocco = scrapertools.find_single_match(data,
-                                            r'<h1 class="entry-title">Aggiornamento Episodi</h1>\s*<div class="entry">(.*?)<p>&nbsp;</p>')
-    patron = r'(?:<span[^>]+>|<strong>|)(<?[^<]*)<a href="([^"]+)"[^>]*>([^<]+)<\/a>'
-    matches = re.compile(patron, re.DOTALL).findall(blocco)
-
-    for scrapedtitle, scrapedurl, scraped_number_and_title in matches:
-        scrapedlang = scrapertools.find_single_match(scraped_number_and_title, r'(SUB-ITA)')
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).replace(scrapedlang, scrapedlang)
-        scrapedtitle = scrapertools.htmlclean(scrapedtitle).strip()
-        fulltitle = scrapedtitle.replace("–", "").replace(' ', '').strip()
-
-        scraped_number_and_title = scrapertools.decodeHtmlentities(scraped_number_and_title.replace('&#215;', 'x'))
-        seasonandep = scrapertools.find_single_match(scraped_number_and_title, r'(\d+x[0-9\-?]+)')
-        extra = r'%s(.*?)(?:<br\s*/>|</p>)'
-
-        # Multi Ep
-        if re.compile(r'[,-]\s*\d+', re.DOTALL).findall(scraped_number_and_title):
-            season = scrapertools.find_single_match(scraped_number_and_title, r'(\d+x)')
-            scraped_number_and_title = scraped_number_and_title.split(',')
-            for ep in scraped_number_and_title:
-                ep = (season + ep if season not in ep else ep).strip()
-                seasonandep = scrapertools.find_single_match(ep, r'(\d+x[0-9\-?]+)')
-                completetitle = "%s %s" % (scrapedtitle, ep)
-
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action="findepvideos",
-                         title=completetitle,
-                         contentSerieName=completetitle,
-                         fulltitle=fulltitle,
-                         url=scrapedurl,
-                         extra=extra % seasonandep.replace('x', '×'),
-                         folder=True))
-            continue
-
-        # Ep singolo
-        correct_scraped_number = seasonandep.replace('x', '×')
-        extra = extra % (correct_scraped_number)
-        completetitle = ("%s %s %s" % (
-            scrapedtitle, scraped_number_and_title, "(%s)" % scrapedlang if scrapedlang else scrapedlang)).strip()
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findepvideos",
-                 title=completetitle,
-                 contentSerieName=completetitle,
-                 fulltitle=fulltitle,
-                 url=scrapedurl,
-                 extra=extra,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    return itemlist
-
-
 def peliculas(item):
     logger.info("kod.italiaserie peliculas")
-    itemlist = []
+    patron = r'<div class="post-thumb">\s*<a href="([^"]+)" title="([^"]+)">\s*<img src="([^"]+)"[^>]+>'
+    list_groups = ["url", "title", "thumb"]
 
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
+    support.log(item.tojson())
 
-    # Estrae i contenuti 
-    patron = '<div class="post-thumb">\s*<a href="([^"]+)" title="([^"]+)">\s*<img src="([^"]+)"[^>]+>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
+    if item.args == "latest":
+        patron += r'.*?aj-eps">(.*?)</span>'
+        data = httptools.downloadpage(item.url).data
+        matches = re.compile(patron, re.S).findall(data)
+        itemlist = []
 
-    for scrapedurl, scrapedtitle, scrapedthumbnail in matches:
-        scrapedplot = ""
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        scrapedurl = scrapedurl.replace("-1/", "-links/")
+        for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedep in matches:
+            itemlist.append(
+                Item(channel=item.channel,
+                     action="seasons",
+                     contentType=item.contentType,
+                     title="[B]" + scrapedtitle + "[/B] " + scrapedep,
+                     fulltitle=scrapedtitle,
+                     show=scrapedtitle,
+                     url=scrapedurl,
+                     extra=item.extra,
+                     args=scrapedep
+                     ))
 
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="episodios",
-                 fulltitle=scrapedtitle,
-                 show=scrapedtitle,
-                 title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 plot=scrapedplot,
-                 folder=True))
+        tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+        return itemlist
+    else:
+        patron_next = r'<a class="next page-numbers" href="(.*?)">'
+        return support.scrape(item, patron, list_groups, patronNext=patron_next, action="seasons")
 
-    # Paginazione
-    patronvideos = '<a class="next page-numbers" href="(.*?)">'
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-
-    if len(matches) > 0:
-        scrapedurl = urlparse.urljoin(item.url, matches[0])
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    return itemlist
 
 def search(item, texto):
     logger.info("[italiaserie.py] " + item.url + " search " + texto)
@@ -173,129 +108,43 @@ def search(item, texto):
         return []
 
 
-def episodios(item):
-    def load_episodios(html, item, itemlist, lang_title):
-        patron = '((?:.*?<a[^h]+href="[^"]+"[^>]+>[^<][^<]+<(?:b|\/)[^>]+>)+)'
-        matches = re.compile(patron).findall(html)
-        for data in matches:
-            # Estrazione
-            scrapedtitle = data.split('<a ')[0]
-            scrapedtitle = re.sub(r'<[^>]*>', '', scrapedtitle).strip()
-            if scrapedtitle != 'Categorie':
-                scrapedtitle = scrapedtitle.replace('&#215;', 'x')
-                scrapedtitle = scrapedtitle.replace('×', 'x')
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action="findvideos",
-                         contentType="episode",
-                         title="[COLOR azure]%s[/COLOR]" % (scrapedtitle + " (" + lang_title + ")"),
-                         url=data,
-                         thumbnail=item.thumbnail,
-                         extra=item.extra,
-                         fulltitle=scrapedtitle + " (" + lang_title + ")" + ' - ' + item.show,
-                         show=item.show))
+def menu(item):
+    patron = r'<li class="cat-item.*?href="([^"]+)".*?>(.*?)</a>'
+    return support.scrape(item, patron, ["url", "title"], action="peliculas")
 
-    logger.info("[italiaserie.py] episodios")
 
-    itemlist = []
+def seasons(item):
+    patron = r'<div class="su-spoiler.*?</i>(.*?)</div>\s+<div class="su-spoiler-content"(.*?)="clearfix">'
+    itemlist = support.scrape(item, patron, ["title", "url"], action="episodios")
 
-    # Download pagina
-    data = httptools.downloadpage(item.url).data
-    data = scrapertools.decodeHtmlentities(data)
-    if 'CLICCA QUI PER GUARDARE TUTTI GLI EPISODI' in data:
-        item.url = re.sub('\-\d+[^\d]+$', '-links', item.url)
-        data = httptools.downloadpage(item.url).data
-        data = scrapertools.decodeHtmlentities(data)
-    data = scrapertools.find_single_match(data, '<div class="entry-content">(.*?)<div class="clear"></div>')
+    if item.args != "":
+        s, ep = scrapertools.find_single_match(item.args, r'(\d+)x(\d+)\s')
+        s = (int(s) - 1)
+        lastitem = itemlist[s]
+        lastitem.args = ep
 
-    lang_titles = []
-    starts = []
-    patron = r"Stagione.*?ITA"
-    matches = re.compile(patron, re.IGNORECASE).finditer(data)
-    for match in matches:
-        season_title = match.group()
-        if season_title != '':
-            lang_titles.append('SUB ITA' if 'SUB' in season_title.upper() else 'ITA')
-            starts.append(match.end())
-
-    i = 1
-    len_lang_titles = len(lang_titles)
-
-    while i <= len_lang_titles:
-        inizio = starts[i - 1]
-        fine = starts[i] if i < len_lang_titles else -1
-
-        html = data[inizio:fine]
-        lang_title = lang_titles[i - 1]
-
-        load_episodios(html, item, itemlist, lang_title)
-
-        i += 1
-
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
+        return episodios(lastitem)
 
     return itemlist
 
 
+def episodios(item):
+    patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>(.*?)</'
+    if item.args != "":
+        ep = int(item.args)
+        patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>\s(Episodio ' + str(ep) + r') .*?</'
+
+    return support.scrape(item, patron, ["url", "title"], data=item.url)
+
+
 def findvideos(item):
-    logger.info("kod.italiaserie findvideos")
-    itemlist = []
+    support.log()
 
-    # Carica la pagina 
-    data = item.url
+    itemlist = support.server(item, data=item.url)
 
-    matches = re.findall(r'<a href="([^"]+)" target="_blank" rel="nofollow">', data, re.DOTALL)
+    itemlist = filtertools.get_links(itemlist, item, list_language)
 
-    data = []
-    for url in matches:
-        url, c = unshortenit.unshorten(url)
-        data.append(url)
-
-    itemlist = servertools.find_video_items(data=str(data))
-
-    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 = item.channel
-        videoitem.contentType = item.contentType
-
-    return itemlist
-
-
-def findepvideos(item):
-    logger.info("kod.italiaserie findepvideos")
-
-    itemlist = []
-
-    # Carica la pagina 
-    data = item.url
-
-    matches = re.findall(r'<a href="([^"]+)"[^>]*>[^<]+</a>', data, re.DOTALL)
-
-    data = []
-    for url in matches:
-        url, c = unshortenit.unshorten(url)
-        data.append(url)
-
-    itemlist = servertools.find_video_items(data=str(data))
-
-    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 = item.channel
-        videoitem.contentType = item.contentType
+    autoplay.start(itemlist, item)
+    support.videolibrary(itemlist, item, 'color blue bold')
 
     return itemlist

From 7014a36a0fbaf8d4c81cb5cc2dc905490976984a Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Thu, 18 Apr 2019 22:23:32 +0200
Subject: [PATCH 03/23] Bugfixes italiaserie

---
 plugin.video.alfa/channels/italiaserie.py | 58 +++++++++++++++--------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/plugin.video.alfa/channels/italiaserie.py b/plugin.video.alfa/channels/italiaserie.py
index 2e0ae31e..22114239 100644
--- a/plugin.video.alfa/channels/italiaserie.py
+++ b/plugin.video.alfa/channels/italiaserie.py
@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Ringraziamo Icarus crew
 # Canale per italiaserie
-# ----------------------------------------------------------
+# ------------------------------------------------------------
 import re
 
 import autoplay
@@ -16,7 +15,6 @@ from platformcode import logger
 host = "https://italiaserie.org"
 
 list_servers = ['speedvideo']
-list_quality = ['1080p', '720p', '480p']
 
 IDIOMAS = {'Italiano': 'IT'}
 list_language = IDIOMAS.values()
@@ -27,11 +25,13 @@ def mainlist(item):
     itemlist = []
 
     support.menu(itemlist, 'Ultime Uscite', 'peliculas', host + "/category/serie-tv/", "episode")
-    support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host + "/ultimi-episodi/", "episode", 'latest')
+    # page not working
+    # support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host + "/ultimi-episodi/", "episode", 'latest')
+    support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host, "episode", 'latest')
     support.menu(itemlist, 'Categorie', 'menu', host, "episode", args="Serie-Tv per Genere")
     support.menu(itemlist, 'Cerca...', 'search', host, 'episode', args='serie')
 
-    autoplay.init(item.channel, list_servers, list_quality)
+    autoplay.init(item.channel, list_servers, [])
     autoplay.show_option(item.channel, itemlist)
 
     return itemlist
@@ -63,19 +63,22 @@ def newest(categoria):
 
 
 def peliculas(item):
-    logger.info("kod.italiaserie peliculas")
+    support.log()
     patron = r'<div class="post-thumb">\s*<a href="([^"]+)" title="([^"]+)">\s*<img src="([^"]+)"[^>]+>'
     list_groups = ["url", "title", "thumb"]
 
-    support.log(item.tojson())
-
     if item.args == "latest":
         patron += r'.*?aj-eps">(.*?)</span>'
         data = httptools.downloadpage(item.url).data
-        matches = re.compile(patron, re.S).findall(data)
+
+        # remove when /ultimi-episodi page will work again
+        block = scrapertools.find_single_match(data, r'<ul class="recent-posts">(.*?)<\/ul>')
+
+        matches = re.compile(patron, re.S).findall(block)
         itemlist = []
 
         for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedep in matches:
+            s, ep = scrapertools.find_single_match(scrapedep, r'(\d+)x(\d+)\s')
             itemlist.append(
                 Item(channel=item.channel,
                      action="seasons",
@@ -85,7 +88,7 @@ def peliculas(item):
                      show=scrapedtitle,
                      url=scrapedurl,
                      extra=item.extra,
-                     args=scrapedep
+                     args={"season": s, "episode": ep}
                      ))
 
         tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
@@ -96,7 +99,7 @@ def peliculas(item):
 
 
 def search(item, texto):
-    logger.info("[italiaserie.py] " + item.url + " search " + texto)
+    support.log("s=", texto)
     item.url = host + "/?s=" + texto
     try:
         return peliculas(item)
@@ -109,42 +112,57 @@ def search(item, texto):
 
 
 def menu(item):
+    support.log()
     patron = r'<li class="cat-item.*?href="([^"]+)".*?>(.*?)</a>'
     return support.scrape(item, patron, ["url", "title"], action="peliculas")
 
 
 def seasons(item):
+    support.log()
+
     patron = r'<div class="su-spoiler.*?</i>(.*?)</div>\s+<div class="su-spoiler-content"(.*?)="clearfix">'
     itemlist = support.scrape(item, patron, ["title", "url"], action="episodios")
 
-    if item.args != "":
-        s, ep = scrapertools.find_single_match(item.args, r'(\d+)x(\d+)\s')
+    if item.args:
+        s = item.args["season"]
         s = (int(s) - 1)
         lastitem = itemlist[s]
-        lastitem.args = ep
+        lastitem.args = {"episode": item.args["episode"]}
 
         return episodios(lastitem)
 
-    return itemlist
+    return itemlist[:-1]
 
 
 def episodios(item):
+    support.log()
+    season = item.fulltitle
+
     patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>(.*?)</'
-    if item.args != "":
-        ep = int(item.args)
+    if item.args:
+        ep = int(item.args["episode"])
         patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>\s(Episodio ' + str(ep) + r') .*?</'
 
-    return support.scrape(item, patron, ["url", "title"], data=item.url)
+    itemlist = support.scrape(item, patron, ["url", "title"], data=item.url)
+
+    if item.args:
+        itemlist = itemlist[:-1]
+
+    for it in itemlist:
+        if it.action == "findvideos":
+            season_n = season.lower().replace("stagione", "").strip()
+            ep_n = scrapertools.find_single_match(it.title, r'Episodio\s+(\d+)')
+            it.title = season_n + "x" + str(ep_n).zfill(2) + re.sub(r"Episodio\s+" + ep_n, "", it.title)
+
+    return itemlist
 
 
 def findvideos(item):
     support.log()
 
     itemlist = support.server(item, data=item.url)
-
     itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
-    support.videolibrary(itemlist, item, 'color blue bold')
 
     return itemlist

From 7f928a4b974a3bff9658f529106debf40fd33a7f Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Fri, 19 Apr 2019 21:13:04 +0200
Subject: [PATCH 04/23] Add parent item title, to add to videolibray item.
 Italiaserie fix

---
 plugin.video.alfa/channels/italiaserie.py | 4 ++--
 plugin.video.alfa/channels/support.py     | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/plugin.video.alfa/channels/italiaserie.py b/plugin.video.alfa/channels/italiaserie.py
index 22114239..debc8fcc 100644
--- a/plugin.video.alfa/channels/italiaserie.py
+++ b/plugin.video.alfa/channels/italiaserie.py
@@ -136,7 +136,7 @@ def seasons(item):
 
 def episodios(item):
     support.log()
-    season = item.fulltitle
+    season = item.parentTitle
 
     patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>(.*?)</'
     if item.args:
@@ -150,7 +150,7 @@ def episodios(item):
 
     for it in itemlist:
         if it.action == "findvideos":
-            season_n = season.lower().replace("stagione", "").strip()
+            season_n = scrapertools.find_single_match(season, r'Stagione\s+(\d+)')
             ep_n = scrapertools.find_single_match(it.title, r'Episodio\s+(\d+)')
             it.title = season_n + "x" + str(ep_n).zfill(2) + re.sub(r"Episodio\s+" + ep_n, "", it.title)
 
diff --git a/plugin.video.alfa/channels/support.py b/plugin.video.alfa/channels/support.py
index 2e916224..600c2ea2 100644
--- a/plugin.video.alfa/channels/support.py
+++ b/plugin.video.alfa/channels/support.py
@@ -397,7 +397,8 @@ def videolibrary(itemlist, item, typography=''):
                  url=item.url,
                  action=action,
                  extra=extra,
-                 contentTitle=item.fulltitle))
+                 contentTitle=item.fulltitle,
+                 parentTitle=item.title))
 
 
 def nextPage(itemlist, item, data, patron, function_level=1):

From 50caf3ea19d98d5dc9493c67b838158fe9ca67c3 Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Sat, 20 Apr 2019 11:42:10 +0200
Subject: [PATCH 05/23] List of all episodes to make add to library work as
 well Updated scrapertools regex to match italian series and episodes number

---
 plugin.video.alfa/channels/italiaserie.py | 76 ++++++++++++-----------
 plugin.video.alfa/channels/support.py     |  3 +-
 plugin.video.alfa/core/scrapertools.py    |  2 +-
 3 files changed, 41 insertions(+), 40 deletions(-)

diff --git a/plugin.video.alfa/channels/italiaserie.py b/plugin.video.alfa/channels/italiaserie.py
index debc8fcc..0c94e5d9 100644
--- a/plugin.video.alfa/channels/italiaserie.py
+++ b/plugin.video.alfa/channels/italiaserie.py
@@ -25,9 +25,7 @@ def mainlist(item):
     itemlist = []
 
     support.menu(itemlist, 'Ultime Uscite', 'peliculas', host + "/category/serie-tv/", "episode")
-    # page not working
-    # support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host + "/ultimi-episodi/", "episode", 'latest')
-    support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host, "episode", 'latest')
+    support.menu(itemlist, 'Ultimi Episodi', 'peliculas', host + "/ultimi-episodi/", "episode", 'latest')
     support.menu(itemlist, 'Categorie', 'menu', host, "episode", args="Serie-Tv per Genere")
     support.menu(itemlist, 'Cerca...', 'search', host, 'episode', args='serie')
 
@@ -71,17 +69,14 @@ def peliculas(item):
         patron += r'.*?aj-eps">(.*?)</span>'
         data = httptools.downloadpage(item.url).data
 
-        # remove when /ultimi-episodi page will work again
-        block = scrapertools.find_single_match(data, r'<ul class="recent-posts">(.*?)<\/ul>')
-
-        matches = re.compile(patron, re.S).findall(block)
+        matches = re.compile(patron, re.S).findall(data)
         itemlist = []
 
         for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedep in matches:
             s, ep = scrapertools.find_single_match(scrapedep, r'(\d+)x(\d+)\s')
             itemlist.append(
                 Item(channel=item.channel,
-                     action="seasons",
+                     action="episodios",
                      contentType=item.contentType,
                      title="[B]" + scrapedtitle + "[/B] " + scrapedep,
                      fulltitle=scrapedtitle,
@@ -95,7 +90,12 @@ def peliculas(item):
         return itemlist
     else:
         patron_next = r'<a class="next page-numbers" href="(.*?)">'
-        return support.scrape(item, patron, list_groups, patronNext=patron_next, action="seasons")
+        itemlist = support.scrape(item, patron, list_groups, patronNext=patron_next, action="episodios")
+
+        if itemlist[-1].action != "peliculas":
+            itemlist.pop()
+
+        return itemlist
 
 
 def search(item, texto):
@@ -117,42 +117,44 @@ def menu(item):
     return support.scrape(item, patron, ["url", "title"], action="peliculas")
 
 
-def seasons(item):
+def episodios(item):
     support.log()
 
     patron = r'<div class="su-spoiler.*?</i>(.*?)</div>\s+<div class="su-spoiler-content"(.*?)="clearfix">'
-    itemlist = support.scrape(item, patron, ["title", "url"], action="episodios")
+    data = httptools.downloadpage(item.url).data
+    matches = re.compile(patron, re.S).findall(data)
 
     if item.args:
-        s = item.args["season"]
-        s = (int(s) - 1)
-        lastitem = itemlist[s]
-        lastitem.args = {"episode": item.args["episode"]}
+        s = (int(item.args["season"]))
+        try:
+            matches = [matches[s]]
+        except:
+            matches = [matches[(s - 1)]]
 
-        return episodios(lastitem)
+    itemlist = []
 
-    return itemlist[:-1]
+    for season, block in matches:
+        patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>(.*?)</'
+        if item.args:
+            ep = int(item.args["episode"])
+            patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>\s(Episodio ' + str(ep) + r') .*?</'
+        episodes = re.compile(patron, re.MULTILINE).findall(block)
+        for scrapedurl, scrapedtitle in episodes:
+            fixedtitle = scrapertools.get_season_and_episode(season + " " + scrapedtitle)
+            eptitle = re.sub(r"Episodio\s+\d+", "", scrapedtitle).strip()
+            itemlist.append(
+                Item(channel=item.channel,
+                     action="episodios",
+                     contentType=item.contentType,
+                     title="[B]" + fixedtitle + " " + eptitle + "[/B]",
+                     fulltitle=fixedtitle + " " + eptitle,
+                     show=fixedtitle + " " + eptitle,
+                     url=scrapedurl,
+                     extra=item.extra,
+                     ))
 
-
-def episodios(item):
-    support.log()
-    season = item.parentTitle
-
-    patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>(.*?)</'
-    if item.args:
-        ep = int(item.args["episode"])
-        patron = r'<div class="su-link-ep">\s+<a.*?href="([^"]+)".*?strong>\s(Episodio ' + str(ep) + r') .*?</'
-
-    itemlist = support.scrape(item, patron, ["url", "title"], data=item.url)
-
-    if item.args:
-        itemlist = itemlist[:-1]
-
-    for it in itemlist:
-        if it.action == "findvideos":
-            season_n = scrapertools.find_single_match(season, r'Stagione\s+(\d+)')
-            ep_n = scrapertools.find_single_match(it.title, r'Episodio\s+(\d+)')
-            it.title = season_n + "x" + str(ep_n).zfill(2) + re.sub(r"Episodio\s+" + ep_n, "", it.title)
+    if not item.args:
+        support.videolibrary(itemlist, item)
 
     return itemlist
 
diff --git a/plugin.video.alfa/channels/support.py b/plugin.video.alfa/channels/support.py
index 7f7a0922..90a323e8 100644
--- a/plugin.video.alfa/channels/support.py
+++ b/plugin.video.alfa/channels/support.py
@@ -397,8 +397,7 @@ def videolibrary(itemlist, item, typography=''):
                  url=item.url,
                  action=action,
                  extra=extra,
-                 contentTitle=item.fulltitle,
-                 parentTitle=item.title))
+                 contentTitle=item.fulltitle))
 
 
 def nextPage(itemlist, item, data, patron, function_level=1):
diff --git a/plugin.video.alfa/core/scrapertools.py b/plugin.video.alfa/core/scrapertools.py
index 8a45645f..5d0be133 100755
--- a/plugin.video.alfa/core/scrapertools.py
+++ b/plugin.video.alfa/core/scrapertools.py
@@ -367,7 +367,7 @@ def get_season_and_episode(title):
     filename = ""
 
     patrons = ["(\d+)\s*[x-]\s*(\d+)", "(\d+)\s*×\s*(\d+)", "(?:s|t)(\d+)e(\d+)",
-               "(?:season|temp\w*)\s*(\d+)\s*(?:capitulo|epi|episode\w*)\s*(\d+)"]
+               "(?:season|temp|stagione\w*)\s*(\d+)\s*(?:capitulo|epi|episode|episodio\w*)\s*(\d+)"]
 
     for patron in patrons:
         try:

From 94efb3f1a2cd59be1931edb985cc6b7b2c123ee5 Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Sat, 20 Apr 2019 21:15:29 +0200
Subject: [PATCH 06/23] Add some more check about duration scraper

---
 plugin.video.alfa/channels/support.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/plugin.video.alfa/channels/support.py b/plugin.video.alfa/channels/support.py
index 90a323e8..373b302d 100644
--- a/plugin.video.alfa/channels/support.py
+++ b/plugin.video.alfa/channels/support.py
@@ -167,8 +167,11 @@ def scrape(item, patron = '', listGroups = [], headers="", blacklist="", data=""
                     infolabels['plot'] = plot
                 if scrapedduration:
                     matches = scrapertoolsV2.find_multiple_matches(scrapedduration, r'([0-9])\s*?(?:[hH]|:|\.|,|\\|\/|\||\s)\s*?([0-9]+)')
+                    scrapertoolsV2.printMatches(matches)
                     for h, m in matches:
                         scrapedduration = int(h) * 60 + int(m)
+                    if not matches:
+                        scrapedduration = scrapertoolsV2.find_single_match(scrapedduration, r'(\d+)')
                     infolabels['duration'] = int(scrapedduration) * 60
                 if scrapedgenre:
                     genres = scrapertoolsV2.find_multiple_matches(scrapedgenre, '[A-Za-z]+')

From b6e9a0d93226a642e2e5a01dc6518bef424936e9 Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Sun, 21 Apr 2019 11:07:24 +0200
Subject: [PATCH 07/23] Enabled cinemastreaming channel

---
 .../channels/cinemastreaming.json             |   2 +-
 plugin.video.alfa/channels/cinemastreaming.py | 229 +++++++++++++-----
 2 files changed, 169 insertions(+), 62 deletions(-)

diff --git a/plugin.video.alfa/channels/cinemastreaming.json b/plugin.video.alfa/channels/cinemastreaming.json
index d229b77b..a738a680 100644
--- a/plugin.video.alfa/channels/cinemastreaming.json
+++ b/plugin.video.alfa/channels/cinemastreaming.json
@@ -2,7 +2,7 @@
 	"id": "cinemastreaming",
 	"name": "Cinemastreaming",
 	"language": ["ita"],
-	"active": false,
+	"active": true,
 	"adult": false,
 	"thumbnail": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",
 	"banner": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",
diff --git a/plugin.video.alfa/channels/cinemastreaming.py b/plugin.video.alfa/channels/cinemastreaming.py
index 84d3df33..e03a1f3e 100644
--- a/plugin.video.alfa/channels/cinemastreaming.py
+++ b/plugin.video.alfa/channels/cinemastreaming.py
@@ -4,77 +4,184 @@
 # ------------------------------------------------------------
 import re
 
-from channels import  filtertools
-from core import scrapertools, servertools, httptools
+from channels import filtertools, support, autoplay
+from core import scrapertools, servertools, httptools, scrapertoolsV2
 from core.item import Item
-from platformcode import config
-from core import tmdb
 
-host = 'https://cinemastreaming.info'
+host = 'https://cinemastreaming.icu'
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+list_servers = ['openload', 'streamango']
+list_quality = ['1080p', '1080p 3D', 'SD', 'CAM', 'default']
 
 headers = [['Referer', host]]
 
+
 def mainlist(item):
-    log()
+    support.log()
 
     # Menu Principale
+    itemlist = []
+    support.menu(itemlist, 'Film bold', 'peliculas', host + '/film/')
+    support.menu(itemlist, 'Per genere submenu', 'menu', host, args="Film per Genere")
+    support.menu(itemlist, 'Anime bold', 'peliculas', host + '/category/anime/')
+    support.menu(itemlist, 'Serie TV bold', 'peliculas', host + '/serie-tv/', contentType='episode')
+    support.menu(itemlist, 'Ultime Uscite submenu', 'peliculas', host + "/stagioni/", "episode", args='latests')
+    support.menu(itemlist, 'Ultimi Episodi submenu', 'peliculas_latest_ep', host + "/episodi/", "episode", args='lateste')
+    support.menu(itemlist, '[COLOR blue]Cerca...[/COLOR]', 'search')
 
-    itemlist = [Item(channel = item.channel,
-                     contentType = 'movie',
-                     title = 'Film',
-                     url = host + '/film/',
-                     action = 'video',
-                     thumbnail = '',
-                     fanart = ''
-                     ),
-    ]
-
-    return itemlist
-
-def video(item):
-    log()
-
-    itemlist = []  # Creo una lista Vuota
-
-    # Carica la pagina
-    data = httptools.downloadpage(item.url, headers=headers).data
-    block = scrapertools.find_single_match(data, r'<main>(.*?)<\/main>')
-    block = re.sub('\t|\n', '', block)
-
-    patron = r'<article.*?class="TPost C">.*?<a href="([^"]+)">.*?src="([^"]+)".*?>.*?<h3 class="Title">([^<]+)<\/h3>(.*?)<\/article>'
-    matches = re.compile(patron, re.DOTALL).findall(block)
-
-    for scrapedurl, scrapedthumb, scrapedtitle, scrapedinfo in matches:
-        log('Info Block', scrapedinfo)
-        patron = r'<span class="Year">(.*?)<\/span>.*?<span class="Vote.*?">(.*?)<\/span>.*?<div class="Description"><p>(.*?)<\/p>.*?<p class="Genre.*?">(.*?)<\/p><p class="Director.*?">.*?<a.*?>(.*?)<\/a>.*?<p class="Actors.*?">(.*?)<\/p>'
-        info = re.compile(patron, re.DOTALL).findall(scrapedinfo)
-        for year, rating, plot, genre, director, cast in info:
-            genre = scrapertools.find_multiple_matches(genre, r'<a.*?>(.*?)<\/a>')
-            cast = scrapertools.find_multiple_matches(cast, r'<a.*?>(.*?)<\/a>')
-            
-            infoLabels = {}
-            infoLabels['Year'] = year
-            infoLabels['Rating'] = rating
-            infoLabels['Plot'] = plot
-            infoLabels['Genre'] = genre
-            infoLabels['Director'] = director
-            infoLabels['Cast'] = cast
-            
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="findvideos",
-                    contentType=item.contentType,
-                    title=scrapedtitle,
-                    fulltitle=scrapedtitle,
-                    url=scrapedurl,
-                    thumbnail=scrapedthumb,
-                    infoLabels = infoLabels,
-                    show=scrapedtitle))
+    autoplay.init(item.channel, list_servers, list_quality)
+    autoplay.show_option(item.channel, itemlist)
 
     return itemlist
 
 
-def log(stringa1="", stringa2=""):
-    import inspect, os
-    from platformcode import logger
-    logger.info("[" + os.path.basename(__file__) + "] - [" + inspect.stack()[1][3] + "] " + str(stringa1) + str(stringa2))
\ No newline at end of file
+def peliculas(item):
+    support.log()
+    list_groups = ["url", "thumb", "title", "year", "rating", "duration"]
+
+    patron = r'<article.*?"TPost C".*?href="([^"]+)".*?img.*?src="([^"]+)".*?<h3.*?>([^<]+).*?Year">'
+
+    if item.args == "latests":
+        patron += r'([^<]+)'
+    else:
+        patron += r'(\d{4}).*?AAIco-star.*?>([^<]+).*?AAIco-access_time">([^<]+).*?Qlty'
+
+    patron_next = r'page-numbers current.*?href="([^"]+)"'
+
+    if item.contentType == "movie":
+        patron += r'\">([^<]+)'
+        list_groups.append("quality")
+
+    action = "findvideos" if item.contentType == "movie" or item.args == "lateste" else "episodios"
+
+    return support.scrape(item, patron, list_groups, patronNext=patron_next, action=action)
+
+
+def peliculas_latest_ep(item):
+
+    patron = r'<article.*?"TPost C".*?href="([^"]+)".*?img.*?src="([^"]+)"'
+    patron += r'.*?class="ClB">([^<]+)<\/span>([^<]+).*?<h3.*?>([^<]+)'
+
+    data = httptools.downloadpage(item.url).data
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    itemlist = []
+    for scrapedurl, scrapedthumbnail, scrapednum, scrapedep, scrapedtitle in matches:
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="findvideos",
+                 contentType=item.contentType,
+                 title="[B]" + scrapednum + "[/B]" + scrapedep + " - " + scrapedtitle,
+                 fulltitle=scrapedep + " " + scrapedtitle,
+                 show=scrapedep + " " + scrapedtitle,
+                 url=scrapedurl,
+                 extra=item.extra,
+                 thumbnail="http:" + scrapedthumbnail,
+                 infoLabels=item.infoLabels
+                 ))
+
+    support.nextPage(itemlist, item, data, r'page-numbers current.*?href="([^"]+)"')
+
+    return itemlist
+
+
+def peliculas_menu(item):
+    itemlist = peliculas(item)
+    return itemlist[:-1]
+
+
+def episodios(item):
+    patron = r'<td class="MvTbTtl"><a href="([^"]+)">(.*?)<\/a>.*?>\d{4}<'
+    list_groups = ["url", "title", "year"]
+
+    itemlist = support.scrape(item, patron, list_groups)
+
+    for itm in itemlist:
+        fixedtitle = scrapertools.get_season_and_episode(itm.url)
+        itm.title = fixedtitle + " - " + itm.title
+        itm.fulltitle = fixedtitle + " - " + itm.fulltitle
+
+    return itemlist
+
+
+def menu(item):
+    patron_block = r'<ul class="sub-menu">.*?</ul>'
+    patron = r'menu-category-list"><a href="([^"]+)">([^<]+)<'
+    list_groups = ["url", "title"]
+
+    return support.scrape(item, patron, list_groups, blacklist="Anime", action="peliculas_menu", patron_block=patron_block)
+
+
+def search(item, texto):
+    support.log("s=", texto)
+    item.url = host + "/?s=" + texto
+    try:
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
+    except Exception, e:
+        import traceback
+        traceback.print_stack()
+        support.log(str(e))
+        return []
+
+
+def newest(categoria):
+    support.log("newest" + categoria)
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == "series":
+            item.url = host + "/episodi/"
+            item.action = "peliculas"
+            item.args = "lateste"
+            item.contentType = "episode"
+            itemlist = peliculas(item)
+
+            if itemlist[-1].action == "peliculas":
+                itemlist.pop()
+
+    # Continua la ricerca in caso di errore
+    except Exception, e:
+        import traceback
+        traceback.print_stack()
+        support.log(str(e))
+        return []
+
+    return itemlist
+
+
+def findvideos(item):
+    itemlist = []
+    data = scrapertoolsV2.decodeHtmlentities(httptools.downloadpage(item.url).data)
+    btns = re.compile(r'data-tplayernv="Opt.*?><span>([^<]+)</span><span>([^<]+)</span>', re.DOTALL).findall(data)
+    matches = re.compile(r'<iframe.*?src="([^"]+trembed=[^"]+)', re.DOTALL).findall(data)
+    for i, scrapedurl in enumerate(matches):
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="play",
+                 contentType=item.contentType,
+                 title="[B]" + btns[i][0] + "[/B] - " + btns[i][1],
+                 fulltitle=btns[i][0] + " " + btns[i][1],
+                 show=btns[i][0] + " " + btns[i][1],
+                 url=scrapedurl,
+                 extra=item.extra,
+                 infoLabels=item.infoLabels
+                 ))
+
+    if item.contentType == "movie":
+        support.videolibrary(itemlist, item)
+    autoplay.start(itemlist, item)
+
+    return itemlist
+
+
+def play(item):
+    patron = r'<iframe.*?src="([^>]+)"'
+    data = httptools.downloadpage(item.url).data
+    url = scrapertoolsV2.find_single_match(data, patron)
+
+    itemlist = support.server(item, url)
+
+    return itemlist

From 62b405a5d6357ae4373ec2a7153c811354917f73 Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Mon, 22 Apr 2019 10:39:59 +0200
Subject: [PATCH 08/23] Cinemastreaming fixes in tvshow search, better way to
 find video url

---
 plugin.video.alfa/channels/cinemastreaming.py | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/plugin.video.alfa/channels/cinemastreaming.py b/plugin.video.alfa/channels/cinemastreaming.py
index e03a1f3e..ce7834c4 100644
--- a/plugin.video.alfa/channels/cinemastreaming.py
+++ b/plugin.video.alfa/channels/cinemastreaming.py
@@ -54,7 +54,7 @@ def peliculas(item):
         patron += r'\">([^<]+)'
         list_groups.append("quality")
 
-    action = "findvideos" if item.contentType == "movie" or item.args == "lateste" else "episodios"
+    action = "findvideos" if item.contentType == "movie" else "episodios"
 
     return support.scrape(item, patron, list_groups, patronNext=patron_next, action=action)
 
@@ -153,11 +153,21 @@ def newest(categoria):
 
 
 def findvideos(item):
+
+    if item.quality.lower() in ["ended", "canceled", "returning series"]:
+        return episodios(item)
+
     itemlist = []
     data = scrapertoolsV2.decodeHtmlentities(httptools.downloadpage(item.url).data)
     btns = re.compile(r'data-tplayernv="Opt.*?><span>([^<]+)</span><span>([^<]+)</span>', re.DOTALL).findall(data)
     matches = re.compile(r'<iframe.*?src="([^"]+trembed=[^"]+)', re.DOTALL).findall(data)
     for i, scrapedurl in enumerate(matches):
+
+        scrapedurl = scrapertoolsV2.decodeHtmlentities(scrapedurl)
+        patron = r'<iframe.*?src="([^"]+)"'
+        link_data = httptools.downloadpage(scrapedurl).data
+        url = scrapertoolsV2.find_single_match(link_data, patron)
+
         itemlist.append(
             Item(channel=item.channel,
                  action="play",
@@ -165,9 +175,11 @@ def findvideos(item):
                  title="[B]" + btns[i][0] + "[/B] - " + btns[i][1],
                  fulltitle=btns[i][0] + " " + btns[i][1],
                  show=btns[i][0] + " " + btns[i][1],
-                 url=scrapedurl,
+                 url=url,
                  extra=item.extra,
-                 infoLabels=item.infoLabels
+                 infoLabels=item.infoLabels,
+                 server=btns[i][0],
+                 contentQuality=btns[i][1].replace('Italiano - ', ''),
                  ))
 
     if item.contentType == "movie":
@@ -176,12 +188,3 @@ def findvideos(item):
 
     return itemlist
 
-
-def play(item):
-    patron = r'<iframe.*?src="([^>]+)"'
-    data = httptools.downloadpage(item.url).data
-    url = scrapertoolsV2.find_single_match(data, patron)
-
-    itemlist = support.server(item, url)
-
-    return itemlist

From ba2eb633a012c34f8c6d0d92ad39e5cb52fb4a1d Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Thu, 2 May 2019 17:49:40 +0200
Subject: [PATCH 09/23] Disable cinemastreaming: site not working

---
 channels/cinemastreaming.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/channels/cinemastreaming.json b/channels/cinemastreaming.json
index a738a680..d229b77b 100644
--- a/channels/cinemastreaming.json
+++ b/channels/cinemastreaming.json
@@ -2,7 +2,7 @@
 	"id": "cinemastreaming",
 	"name": "Cinemastreaming",
 	"language": ["ita"],
-	"active": true,
+	"active": false,
 	"adult": false,
 	"thumbnail": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",
 	"banner": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",

From faac026cec68e726614bfea9473fbe8301ee838a Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Thu, 2 May 2019 18:41:32 +0200
Subject: [PATCH 10/23] Some improvements in scrape: - avoid unwanted calls to
 tmdb, (i.e episodes list) based on action - add custom properties to Item not
 in know_keys list

---
 channels/support.py | 91 ++++++++++++++++++++++++---------------------
 1 file changed, 49 insertions(+), 42 deletions(-)

diff --git a/channels/support.py b/channels/support.py
index 379b44a5..cbbbdf30 100644
--- a/channels/support.py
+++ b/channels/support.py
@@ -135,25 +135,24 @@ def scrape(item, patron = '', listGroups = [], headers="", blacklist="", data=""
         matches = scrapertoolsV2.find_multiple_matches(block, patron)
         log('MATCHES =', matches)
 
+        known_keys = ['url', 'title', 'thumb', 'quality', 'year', 'plot', 'duration', 'genere', 'rating']
         for match in matches:
             if len(listGroups) > len(match):  # to fix a bug
                 match = list(match)
-                match.extend([''] * (len(listGroups)-len(match)))
+                match.extend([''] * (len(listGroups) - len(match)))
 
-            scrapedurl = url_host+match[listGroups.index('url')] if 'url' in listGroups else ''
-            scrapedtitle = match[listGroups.index('title')] if 'title' in listGroups else ''
-            scrapedthumb = match[listGroups.index('thumb')] if 'thumb' in listGroups else ''
-            scrapedquality = match[listGroups.index('quality')] if 'quality' in listGroups else ''
-            scrapedyear = match[listGroups.index('year')] if 'year' in listGroups else ''
-            scrapedplot = match[listGroups.index('plot')] if 'plot' in listGroups else ''
-            scrapedduration = match[listGroups.index('duration')] if 'duration' in listGroups else ''
-            scrapedgenre = match[listGroups.index('genre')] if 'genre' in listGroups else ''
-            scrapedrating = match[listGroups.index('rating')] if 'rating' in listGroups else ''
+            scraped = {}
+            for kk in known_keys:
+                val = match[listGroups.index(kk)] if kk in listGroups else ''
+                if kk == "url":
+                    val = url_host + val
+                scraped[kk] = val
 
-            title = scrapertoolsV2.decodeHtmlentities(scrapedtitle)
-            plot = scrapertoolsV2.decodeHtmlentities(scrapedplot)
-            if scrapedquality:
-                longtitle = '[B]' + title + '[/B] [COLOR blue][' + scrapedquality + '][/COLOR]'
+            title = scrapertoolsV2.decodeHtmlentities(scraped["title"]).strip()
+            plot = scrapertoolsV2.htmlclean(scrapertoolsV2.decodeHtmlentities(scraped["plot"]))
+
+            if scraped["quality"]:
+                longtitle = '[B]' + title + '[/B] [COLOR blue][' + scraped["quality"] + '][/COLOR]'
             else:
                 longtitle = '[B]' + title + '[/B]'
 
@@ -161,40 +160,48 @@ def scrape(item, patron = '', listGroups = [], headers="", blacklist="", data=""
                 infolabels = item.infoLabels
             else:
                 infolabels = {}
-                if scrapedyear:
-                    infolabels['year'] = scrapedyear
-                if scrapedplot:
+                if scraped["year"]:
+                    infolabels['year'] = scraped["year"]
+                if scraped["plot"]:
                     infolabels['plot'] = plot
-                if scrapedduration:
-                    matches = scrapertoolsV2.find_multiple_matches(scrapedduration, r'([0-9])\s*?(?:[hH]|:|\.|,|\\|\/|\||\s)\s*?([0-9]+)')
-                    scrapertoolsV2.printMatches(matches)
+                if scraped["duration"]:
+                    matches = scrapertoolsV2.find_multiple_matches(scraped["duration"],r'([0-9])\s*?(?:[hH]|:|\.|,|\\|\/|\||\s)\s*?([0-9]+)')
                     for h, m in matches:
-                        scrapedduration = int(h) * 60 + int(m)
+                        scraped["duration"] = int(h) * 60 + int(m)
                     if not matches:
-                        scrapedduration = scrapertoolsV2.find_single_match(scrapedduration, r'(\d+)')
-                    infolabels['duration'] = int(scrapedduration) * 60
-                if scrapedgenre:
-                    genres = scrapertoolsV2.find_multiple_matches(scrapedgenre, '[A-Za-z]+')
-                    infolabels['genre'] = ", ".join(genres)
-                if scrapedrating:
-                    infolabels['rating'] = scrapertoolsV2.decodeHtmlentities(scrapedrating)
+                        scraped["duration"] = scrapertoolsV2.find_single_match(scraped["duration"], r'(\d+)')
+                    infolabels['duration'] = int(scraped["duration"]) * 60
+                if scraped["genere"]:
+                    genres = scrapertoolsV2.find_multiple_matches(scraped["genere"], '[A-Za-z]+')
+                    infolabels['genere'] = ", ".join(genres)
+                if scraped["rating"]:
+                    infolabels['rating'] = scrapertoolsV2.decodeHtmlentities(scraped["rating"])
 
-            if not scrapedtitle in blacklist:
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action=action,
-                         contentType=item.contentType,
-                         title=longtitle,
-                         fulltitle=title,
-                         show=title,
-                         quality=scrapedquality,
-                         url=scrapedurl,
-                         infoLabels=infolabels,
-                         thumbnail=scrapedthumb
-                         )
+            if scraped["title"] not in blacklist:
+                it = Item(
+                    channel=item.channel,
+                    action=action,
+                    contentType=item.contentType,
+                    title=longtitle,
+                    fulltitle=title,
+                    show=title,
+                    quality=scraped["quality"],
+                    url=scraped["url"],
+                    infoLabels=infolabels,
+                    thumbnail=scraped["thumb"]
                 )
 
-        tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+                for lg in list(set(listGroups).difference(known_keys)):
+                    it.__setattr__(lg, match[listGroups.index(lg)])
+
+                itemlist.append(it)
+
+        if (item.contentType == "episode" and (action != "findvideos" and action != "play")) \
+                or (item.contentType == "movie" and action != "play"):
+            tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+        else:
+            for it in itemlist:
+                it.infoLabels = item.infoLabels
 
         if patronNext:
             nextPage(itemlist, item, data, patronNext, 2)

From 8253aba9763c845046459ede778b04191c5242ce Mon Sep 17 00:00:00 2001
From: cttynul <cttynul@outlook.com>
Date: Fri, 3 May 2019 18:50:31 +0200
Subject: [PATCH 11/23] test updater

---
 version.json | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 version.json

diff --git a/version.json b/version.json
new file mode 100644
index 00000000..f7706faa
--- /dev/null
+++ b/version.json
@@ -0,0 +1,9 @@
+{
+	"update": {
+        "name": "Kodi on Demand",
+        "version":"100",
+		"tag": "1.0.0",
+		"date": "03/05/2019",
+		"changes": "Added Updater"
+	}
+}
\ No newline at end of file

From e584e43592913138c9c383767fcb976e88a426f0 Mon Sep 17 00:00:00 2001
From: cttynul <cttynul@outlook.com>
Date: Fri, 3 May 2019 18:51:05 +0200
Subject: [PATCH 12/23] serious updater tester

---
 version.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/version.json b/version.json
index f7706faa..eba29b4d 100644
--- a/version.json
+++ b/version.json
@@ -1,8 +1,8 @@
 {
 	"update": {
         "name": "Kodi on Demand",
-        "version":"100",
-		"tag": "1.0.0",
+        "version":"101",
+		"tag": "1.0.1",
 		"date": "03/05/2019",
 		"changes": "Added Updater"
 	}

From 99202645e46eaa8235ed2d1cb90ed10877342d2c Mon Sep 17 00:00:00 2001
From: greko17 <50103632+greko17@users.noreply.github.com>
Date: Fri, 3 May 2019 19:40:44 +0200
Subject: [PATCH 13/23] Aggiunta canali (#14)

* Altadefinizione01 L

speriamo...io me la cavo!

* eurostreaming

Sostituiscono gli attuali che hanno i seguenti problemi:
1. Non aprono tutte le serie, in quanto nella pagina del sito si deve cliccare su una voce per aprire la lista degli episodi
2. Quando si aggiungono una serie nella videoteca e si hanno episodi in italiano e sottotitolati, vengono aggiunti correttamente i titoli in italiano ma i video sono sottotitolati.

* Update unify.py

Proposta per italianizzare le thumb!

* Add files via upload

* Add files via upload

* Delete altadefinizione01_link.json

ops!

* Delete altadefinizione01_link.py

ariops!

* Add files via upload

aggiunti i server in lista_servers

* Update eurostreaming.py


aggiunto autoplay nella home menu

* Altadefinizione 2

Ci sono problemi con la ricerca dei server. Prende o solo openload o quello e un altro

* Update altadefinizione_2.json

tolta la parte serie tv

* Aggiornamento canale

Tolte le voci su TMDB che indicavano la lingua italiana e fatto pulizia di alcuni commenti

* Delete altadefinizione_2.json

da modificare

* Delete altadefinizione_2.py

da modificare

* Cambio url

* fix vari

tra cui l'inserimento in videoteca dei giusti video: o ita o sub-ita
---
 channels/altadefinizione01_club.json |  92 ++++++
 channels/altadefinizione01_club.py   | 370 +++++++++++++++++++++
 channels/altadefinizione01_link.json |  94 ++++++
 channels/altadefinizione01_link.py   | 316 ++++++++++++++++++
 channels/eurostreaming.json          | 122 ++++---
 channels/eurostreaming.py            | 463 ++++++++++++++++++---------
 platformcode/unify.py                | 141 ++++----
 7 files changed, 1359 insertions(+), 239 deletions(-)
 create mode 100644 channels/altadefinizione01_club.json
 create mode 100644 channels/altadefinizione01_club.py
 create mode 100644 channels/altadefinizione01_link.json
 create mode 100644 channels/altadefinizione01_link.py

diff --git a/channels/altadefinizione01_club.json b/channels/altadefinizione01_club.json
new file mode 100644
index 00000000..4c4d2fa3
--- /dev/null
+++ b/channels/altadefinizione01_club.json
@@ -0,0 +1,92 @@
+{
+  "id": "altadefinizione01_club",
+  "name": "Altadefinizione01 C",
+  "active": true,
+  "adult": false,
+  "language": ["ita"],
+  "fanart": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
+  "thumbnail": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
+  "banner": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
+  "categories": [
+    "movie"
+  ],
+  "settings": [
+    {
+      "id": "modo_grafico",
+      "type": "bool",
+      "label": "Buscar información extra",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_film",
+      "type": "bool",
+      "label": "Includi in Novità",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+     "id": "include_in_newest_italiano",
+      "type": "bool",
+      "label": "Includi in Novità - Italiano",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },  
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Includi ricerca globale",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces",
+      "type": "bool",
+      "label": "Verifica se i link esistono",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces_num",
+      "type": "list",
+      "label": "Numero de link da verificare",
+      "default": 1,
+      "enabled": true,
+      "visible": "eq(-1,true)",
+      "lvalues": [ "5", "10", "15", "20" ]
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostra link in lingua...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Non filtrare",
+        "IT"
+      ]
+    },
+    {
+      "id": "perfil",
+      "type": "list",
+      "label": "profilo dei colori",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Sin color",
+        "Perfil 5",
+        "Perfil 4",
+        "Perfil 3",
+        "Perfil 2",
+        "Perfil 1"
+      ]
+    }
+	  ]
+}
diff --git a/channels/altadefinizione01_club.py b/channels/altadefinizione01_club.py
new file mode 100644
index 00000000..7969deb5
--- /dev/null
+++ b/channels/altadefinizione01_club.py
@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*-
+# -*- Channel Altadefinizione01C Film -*-
+# -*- Created for IcarusbyGreko -*-
+# -*- By Greko -*-
+# -*- last change: 3/05/2019
+
+from channelselector import get_thumb
+from channels import autoplay
+from channels import filtertools
+from core import httptools
+from core import scrapertools
+from core import servertools
+from core.item import Item
+from core import channeltools
+from core import tmdb
+from platformcode import config, logger
+
+__channel__ = "altadefinizione01_club"
+
+#host = "https://www.altadefinizione01.club/" # host da cambiare
+#host = "https://www.altadefinizione01.team/" #aggiornato al 22 marzo 2019
+host = "https://www.altadefinizione01.vision/" #aggiornato al 30-04-209
+# ======== def per utility INIZIO =============================
+try:
+    __modo_grafico__ = config.get_setting('modo_grafico', __channel__)
+    __perfil__ = int(config.get_setting('perfil', __channel__))
+except:
+    __modo_grafico__ = True
+    __perfil__ = 0
+
+# Fijar perfil de color
+perfil = [['0xFFFFE6CC', '0xFFFFCE9C', '0xFF994D00', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFFA5F6AF', '0xFF5FDA6D', '0xFF11811E', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFF58D3F7', '0xFF2E9AFE', '0xFF2E64FE', '0xFFFE2E2E', '0xFFFFD700']]
+
+if __perfil__ < 3:
+    color1, color2, color3, color4, color5 = perfil[__perfil__]
+else:
+    color1 = color2 = color3 = color4 = color5 = ""
+
+__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', __channel__)
+__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', __channel__)
+
+headers = [['User-Agent', 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0'],
+           ['Referer', host]]
+
+#parameters = channeltools.get_channel_parameters(__channel__)
+#fanart_host = parameters['fanart']
+#thumbnail_host = parameters['thumbnail']
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+list_servers = ['verystream','openload','rapidvideo','streamango'] # per l'autoplay
+list_quality = ['default'] #'rapidvideo', 'streamango', 'openload', 'streamcherry'] # per l'autoplay
+
+
+# =========== home menu ===================
+
+def mainlist(item):
+    """
+    Creo il menu principale del canale
+    :param item:
+    :return: itemlist []
+    """
+    logger.info("%s mainlist log: %s" % (__channel__, item))
+    itemlist = []
+    title = ''
+
+    autoplay.init(item.channel, list_servers, list_quality)
+    
+    itemlist = [
+        # new upload
+        Item(channel=__channel__, title="Ultimi Arrivi", action="peliculas",
+             url="%s" % host, text_color=color4, extra="film",
+             infoLabels={'plot': item.category},
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x to Cinema
+        Item(channel=__channel__, title="Al Cinema", action="peliculas",
+             url="%scinema/" % host, text_color=color4, extra="film",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),
+        # x Sub-ita
+        Item(channel=__channel__, title="Sottotitolati", action="peliculas",
+             url="%ssub-ita/" % host, text_color=color4, extra="film",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),
+        # x Category
+        Item(channel=__channel__, title="Generi", action="categorie",
+             url="%s" % host, text_color=color4, extra="genres",
+             viewcontent='movies',
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),
+        # x year
+        Item(channel=__channel__, title="Anno", action="categorie",
+             url="%s" % host, text_color=color4, extra="year",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),
+       # x lettera
+       Item(channel=__channel__, title="Lettera", action="categorie",
+            url="%scatalog/a/" % host, text_color=color4, extra="orderalf",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+            ),
+        # Search
+        Item(channel=__channel__, title="Cerca Film...", action="search",
+             text_color=color4, extra="",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),
+                ]
+
+    autoplay.show_option(item.channel, itemlist)
+    
+    return itemlist
+
+# ======== def in ordine di menu ===========================
+# =========== def per vedere la lista dei film =============
+
+def peliculas(item):
+    logger.info("%s mainlist peliculas log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+    # da qui fare le opportuni modifiche
+    if item.extra != 'orderalf':
+        if item.extra == 'film' or item.extra == 'year':
+            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)<div id="right_bar">')
+        elif item.extra == "search":
+            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)</a>')
+        else: #item.extra == 'cat':
+            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)<div class="page_nav">')
+        patron = '<h2>.<a href="(.*?)".*?src="(.*?)".*?class="trdublaj">(.*?)<div class="ml-item-hiden".*?class="h4">(.*?)<.*?label">(.*?)</span'
+        matches = scrapertools.find_multiple_matches(data, patron)
+        for scrapedurl, scrapedimg, scrapedqualang, scrapedtitle, scrapedyear in matches:
+
+            if 'sub ita' in scrapedqualang.lower():
+                scrapedlang = 'Sub-Ita'
+            else:
+                scrapedlang = 'ITA'
+            itemlist.append(Item(
+                channel=item.channel,
+                action="findvideos_film",
+                contentTitle=scrapedtitle,
+                fulltitle=scrapedtitle,
+                url=scrapedurl,
+                infoLabels={'year': scrapedyear},
+                contenType="movie",
+                thumbnail=host+scrapedimg,
+                title= "%s [%s]" % (scrapedtitle, scrapedlang),
+                text_color=color5,
+                language=scrapedlang
+                ))
+
+    # se il sito permette l'estrazione dell'anno del film aggiungere la riga seguente
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazione
+    next_page = scrapertools.find_single_match(data, "<link rel='next' href='(.*?)' />")
+    if not next_page:
+        next_page = scrapertools.find_single_match(data, '<span>\d</span> <a href="([^"]+)">')
+
+    if next_page != "":
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="peliculas",
+                 title=config.get_localized_string(30992),
+                 url=next_page,
+                 extra=item.extra,
+                 text_color=color4,
+                 #thumbnail="http://icons.iconarchive.com/icons/ahmadhania/spherical/128/forward-icon.png"
+                 thumbnail= get_thumb('nextpage', auto = True)
+                 ))
+
+    return itemlist
+
+# =========== def pagina categorie ======================================
+
+def categorie(item):
+    logger.info("%s mainlist categorie log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    # da qui fare le opportuni modifiche
+    if item.extra == 'genres':
+        bloque = scrapertools.find_single_match(data, '<ul class="kategori_list">(.*?)</ul>')
+        patron = '<li><a href="/(.*?)">(.*?)</a>'
+    elif item.extra == 'year':
+        bloque = scrapertools.find_single_match(data, '<ul class="anno_list">(.*?)</ul>')
+        patron = '<li><a href="/(.*?)">(.*?)</a>'
+    elif item.extra == 'orderalf':
+        bloque = scrapertools.find_single_match(data, '<div class="movies-letter">(.*)<div class="clearfix">')
+        patron = '<a title=.*?href="(.*?)"><span>(.*?)</span>'
+
+    matches = scrapertools.find_multiple_matches(bloque, patron)
+
+    for scrapurl, scraptitle in sorted(matches):
+
+        if "01" in scraptitle:
+          continue
+        else:
+          scrapurl = host+scrapurl
+
+        if item.extra != 'orderalf':
+            action = "peliculas"
+        else:
+            action = 'orderalf'
+        itemlist.append(Item(
+            channel=item.channel,
+            action= action,
+            title = scraptitle,
+            url= scrapurl,
+            text_color=color4,
+            thumbnail = get_thumb(scraptitle, auto = True),
+            extra = item.extra,
+            #Folder = True,
+        ))
+
+    return itemlist
+
+# =========== def pagina lista alfabetica ===============================
+
+def orderalf(item):
+    logger.info("%s mainlist orderalf log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+    # da qui fare le opportuni modifiche
+    patron = '<td class="mlnh-thumb"><a href="(.*?)".title="(.*?)".*?src="(.*?)".*?mlnh-3">(.*?)<.*?"mlnh-5">.<(.*?)<td' #scrapertools.find_single_match(data, '<td class="mlnh-thumb"><a href="(.*?)".title="(.*?)".*?src="(.*?)".*?mlnh-3">(.*?)<.*?"mlnh-5">.<(.*?)<td')
+    matches = scrapertools.find_multiple_matches(data, patron)
+    for scrapedurl, scrapedtitle, scrapedimg, scrapedyear, scrapedqualang in matches:
+
+            if 'sub ita' in scrapedqualang.lower():
+                scrapedlang = 'Sub-ita'
+            else:
+                scrapedlang = 'ITA'
+            itemlist.append(Item(
+                channel=item.channel,
+                action="findvideos_film",
+                contentTitle=scrapedtitle,
+                fulltitle=scrapedtitle,
+                url=scrapedurl,
+                infoLabels={'year': scrapedyear},
+                contenType="movie",
+                thumbnail=host+scrapedimg,
+                #title=scrapedtitle + ' %s' % scrapedlang,
+                title = "%s [%s]" % (scrapedtitle, scrapedlang),
+                text_color=color5,
+                language=scrapedlang,
+                context="buscar_trailer"
+            ))
+
+    # se il sito permette l'estrazione dell'anno del film aggiungere la riga seguente
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazione
+    next_page = scrapertools.find_single_match(data, "<link rel='next' href='(.*?)' />")
+    if not next_page:
+        next_page = scrapertools.find_single_match(data, '<div class=\'wp-pagenavi\'>.*?href="(.*?)">')
+
+    if next_page != "":
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="orderalf",
+                 title=config.get_localized_string(30992),
+                 url=next_page,
+                 extra=item.extra,
+                 text_color=color4,
+                 thumbnail= get_thumb('nextpage', auto = True)
+                 ))
+
+    return itemlist
+
+# =========== def pagina del film con i server per verderlo =============
+
+def findvideos_film(item):
+    logger.info("%s mainlist findvideos_film log: %s" % (__channel__, item))
+    itemlist = []
+
+    # scarico la pagina
+    #data = scrapertools.cache_page(item.url)
+    data = httptools.downloadpage(item.url, headers=headers).data
+    # da qui fare le opportuni modifiche
+    patron = '<a href="#" data-link="(.*?)">'
+    matches = scrapertools.find_multiple_matches(data, patron)
+
+    for scrapedurl in matches:
+        logger.info("altadefinizione01_club scrapedurl log: %s" % scrapedurl)
+        try:
+            itemlist = servertools.find_video_items(data=data)
+
+            for videoitem in itemlist:
+                logger.info("Videoitemlist2: %s" % videoitem)
+                videoitem.title = "%s [%s]" % (item.contentTitle, videoitem.title)#"[%s] %s" % (videoitem.server, item.title) #"[%s]" % (videoitem.title)
+                videoitem.show = item.show
+                videoitem.contentTitle = item.contentTitle
+                videoitem.contentType = item.contentType
+                videoitem.channel = item.channel
+                videoitem.text_color = color5
+                videoitem.year = item.infoLabels['year']
+                videoitem.infoLabels['plot'] = item.infoLabels['plot']
+        except AttributeError:
+            logger.error("data doesn't contain expected URL")
+
+    # Controlla se i link sono validi
+    if __comprueba_enlaces__:
+        itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
+
+    # Requerido para FilterTools
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    # Requerido para AutoPlay
+    autoplay.start(itemlist, item)
+    
+    # Opción "Añadir esta película a la biblioteca de KODI"
+    if item.extra != "library":
+
+        itemlist.append(Item(channel=__channel__, title="Aggiungi alla Videoteca", text_color="green",
+                             action="add_pelicula_to_library", url=item.url,
+                             thumbnail= get_thumb('videolibrary', auto = True),
+                             contentTitle=item.contentTitle, infoLabels = item.infoLabels
+                             ))
+    
+    return itemlist
+
+# =========== def per cercare film/serietv =============
+#http://altadefinizione01.link/index.php?do=search&story=avatar&subaction=search
+def search(item, text):
+    logger.info("%s mainlist search log: %s %s" % (__channel__, item, text))
+    itemlist = []
+    text = text.replace(" ", "+")
+    item.url = host+"index.php?do=search&story=%s&subaction=search" % (text)
+    item.extra = "search"
+    try:
+        return peliculas(item)
+    # 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 Sono qua: %s" % (__channel__, line))
+        return []
+
+# =========== def per le novità nel menu principale =============
+
+def newest(categoria):
+    logger.info("%s mainlist newest log: %s %s %s" % (__channel__, categoria))
+    itemlist = []
+    item = Item()
+    #item.extra = 'film'
+    try:
+        if categoria == "film":
+            item.url = host
+            item.action = "peliculas"
+            itemlist = peliculas(item)
+            if itemlist[-1].action == "peliculas":
+                itemlist.pop()
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
diff --git a/channels/altadefinizione01_link.json b/channels/altadefinizione01_link.json
new file mode 100644
index 00000000..c43a2939
--- /dev/null
+++ b/channels/altadefinizione01_link.json
@@ -0,0 +1,94 @@
+{
+  "id": "altadefinizione01_link",
+  "name": "Altadefinizione01 L",
+  "active": true,
+  "adult": false,
+  "language": ["ita"],
+  "fanart": "",
+  "thumbnail": "",
+  "banner": "http://altadefinizione01.link/templates/Dark/img/logonyy.png",
+  "fix" : "reimpostato url e modificato file per KOD",
+  "change_date": "2019-30-04",
+  "categories": [
+    "movie"
+  ],
+  "settings": [
+    {
+      "id": "modo_grafico",
+      "type": "bool",
+      "label": "Buscar información extra",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_film",
+      "type": "bool",
+      "label": "Includi in Novità",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "include_in_newest_italiano",
+      "type": "bool",
+      "label": "Includi in Novità - Italiano",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },   
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Includi ricerca globale",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces",
+      "type": "bool",
+      "label": "Verifica se i link esistono",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces_num",
+      "type": "list",
+      "label": "Numero de link da verificare",
+      "default": 1,
+      "enabled": true,
+      "visible": "eq(-1,true)",
+      "lvalues": [ "5", "10", "15", "20" ]
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostra link in lingua...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Non filtrare",
+        "IT"
+      ]
+    },
+    {
+      "id": "perfil",
+      "type": "list",
+      "label": "profilo dei colori",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Sin color",
+        "Perfil 5",
+        "Perfil 4",
+        "Perfil 3",
+        "Perfil 2",
+        "Perfil 1"
+      ]
+    }
+	  ]
+}
diff --git a/channels/altadefinizione01_link.py b/channels/altadefinizione01_link.py
new file mode 100644
index 00000000..f422bcf7
--- /dev/null
+++ b/channels/altadefinizione01_link.py
@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+# -*- Channel Altadefinizione01L Film - Serie -*-
+# -*- Creato per Alfa-addon -*-
+# -*- e adattato for KOD -*-
+# -*- By Greko -*-
+# -*- last change: 3/05/2019
+
+from channelselector import get_thumb
+from channels import autoplay
+from channels import filtertools
+from core import httptools
+from core import scrapertools
+from core import servertools
+from core.item import Item
+from core import channeltools
+from core import tmdb
+from platformcode import config, logger
+
+__channel__ = "altadefinizione01_link"
+
+#host = "https://altadefinizione01.link/" #riaggiornato al 29 aprile 2019
+#host = "http://altadefinizione01.art/" # aggiornato al 22 marzo 2019
+#host = "https://altadefinizione01.network/" #aggiornato al 22 marzo 2019
+#host = "http://altadefinizione01.date/" #aggiornato al 3 maggio 2019
+host = "https://altadefinizione01.voto/" #aggiornato al 3 maggio 2019
+
+# ======== def per utility INIZIO =============================
+try:
+    __modo_grafico__ = config.get_setting('modo_grafico', __channel__)
+    __perfil__ = int(config.get_setting('perfil', __channel__))
+except:
+    __modo_grafico__ = True
+    __perfil__ = 0
+
+# Fijar perfil de color
+perfil = [['0xFFFFE6CC', '0xFFFFCE9C', '0xFF994D00', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFFA5F6AF', '0xFF5FDA6D', '0xFF11811E', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFF58D3F7', '0xFF2E9AFE', '0xFF2E64FE', '0xFFFE2E2E', '0xFFFFD700']]
+
+if __perfil__ < 3:
+    color1, color2, color3, color4, color5 = perfil[__perfil__]
+else:
+    color1 = color2 = color3 = color4 = color5 = ""
+    
+__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', __channel__)
+__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', __channel__)
+
+headers = [['User-Agent', 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0'],
+           ['Referer', host]]#,['Accept-Language','it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3']]
+
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+list_servers = ['openload', 'streamcherry','rapidvideo', 'streamango', 'supervideo']
+list_quality = ['default']
+
+# =========== home menu ===================
+
+def mainlist(item):
+    """
+    Creo il menu principale del canale
+    :param item:
+    :return: itemlist []
+    """
+    logger.info("%s mainlist log: %s" % (__channel__, item))
+    itemlist = []
+    title = ''
+
+    autoplay.init(item.channel, list_servers, list_quality)
+    
+    itemlist = [
+        # new upload
+        Item(channel=__channel__, title="Ultimi Arrivi", action="peliculas",
+             url="%s" % host, text_color=color4, extra="film", # color4 = red
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x to Cinema
+        Item(channel=__channel__, title="Al Cinema", action="peliculas",
+             url="%sfilm-del-cinema" % host, text_color=color4, extra="",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # Popolari
+        Item(channel=__channel__, title="Popolari", action="peliculas",
+             url="%spiu-visti.html" % host, text_color=color4, extra="",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x Sub-ita
+        Item(channel=__channel__, title="Sottotitolati", action="peliculas",
+             url="%sfilm-sub-ita/" % host, text_color=color4, extra="",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x mi sento fortunato - Prende solo film con player a pagamento
+        Item(channel=__channel__, title="Mi Sento Fortunato", action="categorie",
+             url="%s" % host, text_color=color4, extra="lucky",
+             thumbnail=""),
+        # x Category
+        Item(channel=__channel__, title="Generi", action="categorie",
+             url="%s" % host, text_color=color4, extra="genres",
+             viewcontent='movies',
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x year
+        Item(channel=__channel__, title="Anno", action="categorie",
+             url="%s" % host, text_color=color4, extra="year",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # x quality
+        Item(channel=__channel__, title="Qualità", action="categorie",
+             url="%s" % host, text_color=color4, extra="quality",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+        # Search
+        Item(channel=__channel__, title="Cerca Film...", action="search",
+             text_color=color4, extra="",
+             thumbnail=get_thumb(title, auto = True)
+             ),
+                ]
+
+    autoplay.show_option(item.channel, itemlist)
+    
+    return itemlist
+
+# ======== def in ordine di menu ===========================
+
+def peliculas(item):
+    logger.info("%s mainlist peliculas log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    # da qui fare le opportuni modifiche
+    patron = 'class="innerImage">.*?href="([^"]+)".*?src="([^"]+)".*?'\
+             'class="ml-item-title">([^"]+)</.*?class="ml-item-label">'\
+             '(.*?)<.*?class="ml-item-label">.*?class="ml-item-label">(.*?)</'
+    matches = scrapertools.find_multiple_matches(data, patron)
+
+    for scrapedurl, scrapedimg, scrapedtitle, scrapedyear, scrapedlang in matches:
+        if 'italiano' in scrapedlang.lower():
+            scrapedlang = 'ITA'
+        else:
+            scrapedlang = 'Sub-Ita'
+        itemlist.append(Item(
+            channel=item.channel,
+            action="findvideos_film",
+            contentTitle=scrapedtitle,
+            fulltitle=scrapedtitle,
+            url=scrapedurl,
+            infoLabels={'year': scrapedyear},
+            contenType="movie",
+            thumbnail=scrapedimg,
+            title="%s [%s]" % (scrapedtitle, scrapedlang),
+            text_color=color5,
+            language=scrapedlang,
+            context="buscar_trailer"
+        ))
+
+    # poiché c'è l'anno negli item prendiamo le info direttamente da tmdb, anche se a volte può non esserci l'informazione
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazione
+    next_page = scrapertools.find_single_match(data, "<link rel='next' href='(.*?)' />")
+    if not next_page:
+        next_page = scrapertools.find_single_match(data, '<span>\d</span> <a href="([^"]+)">')
+
+    if next_page != "":
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="peliculas",
+                 title=config.get_localized_string(30992),
+                 url=next_page,
+                 extra=item.extra,
+                 text_color=color4,
+                 thumbnail= get_thumb('nextpage', auto = True)
+                 ))
+                    
+    return itemlist
+
+# =========== def pagina categorie ======================================
+
+def categorie(item):
+    logger.info("%s mainlist categorie log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    # da qui fare le opportuni modifiche
+    if item.extra == 'genres':
+        bloque = scrapertools.find_single_match(data, '<ul class="listSubCat" id="Film">(.*?)</ul>')
+    elif item.extra == 'year':
+        bloque = scrapertools.find_single_match(data, '<ul class="listSubCat" id="Anno">(.*?)</ul>')
+    elif item.extra == 'quality':
+        bloque = scrapertools.find_single_match(data, '<ul class="listSubCat" id="Qualita">(.*?)</ul>')
+    elif item.extra == 'lucky': # sono i titoli random nella pagina, alcuni rimandano solo a server a pagamento
+        bloque = scrapertools.find_single_match(data, 'FILM RANDOM.*?class="listSubCat">(.*?)</ul>')        
+    patron = '<li><a href="/(.*?)">(.*?)<'
+    matches = scrapertools.find_multiple_matches(bloque, patron)
+
+    if item.extra == 'lucky':
+        bloque = scrapertools.find_single_match(data, 'FILM RANDOM.*?class="listSubCat">(.*?)</ul>')    
+        patron = '<li><a href="(.*?)">(.*?)<'
+        matches = scrapertools.find_multiple_matches(bloque, patron)
+        
+    for scrapurl, scraptitle in sorted(matches):
+        if item.extra != 'lucky':
+            url = host+scrapurl
+            action="peliculas"
+        else:
+            url = scrapurl
+            action = "findvideos_film"
+        itemlist.append(Item(
+            channel=item.channel,
+            action=action,
+            title = scraptitle,
+            url=url,
+            #extra = '',
+            text_color=color4,
+            thumbnail=get_thumb(scraptitle, auto = True),
+            Folder = True,
+        ))
+
+    return itemlist
+
+
+# =========== def pagina del film con i server per verderlo =============
+# da sistemare che ne da solo 1 come risultato
+
+def findvideos_film(item):
+    logger.info("%s mainlist findvideos_film log: %s" % (__channel__, item))
+    itemlist = []
+    # scarico la pagina
+    #data = scrapertools.cache_page(item.url) #non funziona più?
+    data = httptools.downloadpage(item.url, headers=headers).data
+    # da qui fare le opportuni modifiche
+    patron = '<li.*?<a href="#" data-target="(.*?)">'
+    matches = scrapertools.find_multiple_matches(data, patron)
+    #logger.info("altadefinizione01_linkMATCHES: %s " % matches)
+    for scrapedurl in matches:
+
+        try:
+            itemlist = servertools.find_video_items(data=data)
+
+            for videoitem in itemlist:
+                logger.info("Videoitemlist2: %s" % videoitem)
+                videoitem.title = "%s [%s]" % (item.contentTitle, videoitem.title)#"[%s] %s" % (videoitem.server, item.title) #"[%s]" % (videoitem.title)
+                videoitem.show = item.show
+                videoitem.contentTitle = item.contentTitle
+                videoitem.contentType = item.contentType
+                videoitem.channel = item.channel
+                videoitem.text_color = color5
+                videoitem.year = item.infoLabels['year']
+                videoitem.infoLabels['plot'] = item.infoLabels['plot']
+        except AttributeError:
+            logger.error("data doesn't contain expected URL")
+
+    # Controlla se i link sono validi
+    if __comprueba_enlaces__:
+        itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
+
+    # Requerido para FilterTools
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    # Requerido para AutoPlay
+    autoplay.start(itemlist, item)
+    
+    # Opción "Añadir esta película a la biblioteca de KODI"
+    if item.extra != "library":
+
+        itemlist.append(Item(channel=__channel__, title="Aggiungi alla Videoteca", text_color="green",
+                             action="add_pelicula_to_library", url=item.url,
+                             thumbnail= get_thumb('videolibrary', auto = True),
+                             contentTitle=item.contentTitle, infoLabels = item.infoLabels
+                             ))
+
+    return itemlist
+
+# =========== def per cercare film/serietv =============
+#host+/index.php?do=search&story=avatar&subaction=search
+def search(item, text):
+    logger.info("%s mainlist search log: %s %s" % (__channel__, item, text))
+    itemlist = []
+    text = text.replace(" ", "+")
+    item.url = host+"/index.php?do=search&story=%s&subaction=search" % (text)
+    #item.extra = "search"
+    try:
+        return peliculas(item)
+    # 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.info("%s mainlist search log: %s" % (__channel__, line))
+        return []
+
+# =========== def per le novità nel menu principale =============
+
+def newest(categoria):
+    logger.info("%s mainlist search log: %s" % (__channel__, categoria))
+    itemlist = []
+    item = Item()
+    #item.extra = 'film'
+    try:
+        if categoria == "film":
+            item.url = host
+            item.action = "peliculas"
+            itemlist = peliculas(item)
+
+            if itemlist[-1].action == "peliculas":
+                itemlist.pop()
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
diff --git a/channels/eurostreaming.json b/channels/eurostreaming.json
index d1502022..186b3a5b 100644
--- a/channels/eurostreaming.json
+++ b/channels/eurostreaming.json
@@ -1,44 +1,90 @@
 {
 	"id": "eurostreaming",
 	"name": "Eurostreaming",
-	"language": ["ita"],
-	"active": true,
+    "active": true,
 	"adult": false,
-	"thumbnail": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/eurostreaming.png",
-	"banner": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/eurostreaming.png",
+	"language": ["ita"],
+    "thumbnail": "",
+    "bannermenu": "",
 	"categories": ["tvshow","anime"],
-	"settings": [
-		{
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-		},		
-		{
-			"id": "include_in_newest_series",
-			"type": "bool",
-			"label": "Includi in Novità - Serie TV",
-			"default": true,
-			"enabled": true,
-			"visible": true
-		},
-		{
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-		{
-			"id": "include_in_newest_italiano",
-			"type": "bool",
-			"label": "Includi in Novità - Italiano",
-			"default": true,
-			"enabled": true,
-			"visible": true
-		}
-	]
+  "settings": [
+      {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Includi ricerca globale",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "modo_grafico",
+      "type": "bool",
+      "label": "Buscar información extra",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+    "id": "include_in_newest_series",
+    "type": "bool",
+    "label": "Includi in novità - Serie TV",
+    "default": true,
+	 "enabled": true,
+    "visible": true
+    },
+    {
+    "id": "include_in_newest_italiano",
+    "type": "bool",
+    "label": "Includi in Novità - Italiano",
+    "default": true,
+    "enabled": true,
+    "visible": true
+    },    
+    {
+      "id": "comprueba_enlaces",
+      "type": "bool",
+      "label": "Verifica se i link esistono",
+      "default": true,
+      "enabled": true,
+      "visible": true
+    },
+    {
+      "id": "comprueba_enlaces_num",
+      "type": "list",
+      "label": "Numero de link da verificare",
+      "default": 1,
+      "enabled": true,
+      "visible": "eq(-1,true)",
+      "lvalues": [ "5", "10", "15", "20" ]
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostra link in lingua...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Non filtrare",
+        "ITA",
+        "SUB ITA"
+      ]
+    },
+    {
+      "id": "perfil",
+      "type": "list",
+      "label": "profilo dei colori",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "Sin color",
+        "Perfil 5",
+        "Perfil 4",
+        "Perfil 3",
+        "Perfil 2",
+        "Perfil 1"
+      ]
+    }
+	  ]
 }
diff --git a/channels/eurostreaming.py b/channels/eurostreaming.py
index 58a2fe2d..0b358c1b 100644
--- a/channels/eurostreaming.py
+++ b/channels/eurostreaming.py
@@ -1,65 +1,119 @@
 # -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Ringraziamo Icarus crew
-# Canale per eurostreaming
-# ------------------------------------------------------------
-import re, urlparse
+# -*- Created or modificated for Alfa-Addon -*-
+# -*- adpted for KOD -*-
+# -*- By Greko -*-
 
-from channels import autoplay
-from core import scrapertools, httptools, servertools, tmdb, scrapertoolsV2
-from core.item import Item
+#import base64
+import re
+import urlparse
+# gli import sopra sono da includere all'occorrenza
+# per url con ad.fly
 from lib import unshortenit
-from platformcode import logger, config
-from channelselector import thumb
 
-host = "https://eurostreaming.cafe"
-list_servers = ['verystream', 'openload', 'speedvideo', 'wstream', 'streamango' 'flashx', 'nowvideo']
-list_quality = ['default']
+from channelselector import get_thumb
+from channels import autoplay
+from channels import filtertools
+from core import httptools
+from core import scrapertoolsV2
+from core import servertools
+from core.item import Item
+from core import channeltools
+from core import tmdb
+from platformcode import config, logger
 
+__channel__ = "eurostreaming" #stesso di id nel file json
+
+#host = "https://eurostreaming.zone/"
+#host = "https://eurostreaming.black/" 
+host = "https://eurostreaming.cafe/" #aggiornato al 30-04-2019
+
+# ======== def per utility INIZIO =============================
+try:
+    __modo_grafico__ = config.get_setting('modo_grafico', __channel__)
+    __perfil__ = int(config.get_setting('perfil', __channel__))
+except:
+    __modo_grafico__ = True
+    __perfil__ = 0
+
+# Fijar perfil de color
+perfil = [['0xFFFFE6CC', '0xFFFFCE9C', '0xFF994D00', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFFA5F6AF', '0xFF5FDA6D', '0xFF11811E', '0xFFFE2E2E', '0xFFFFD700'],
+          ['0xFF58D3F7', '0xFF2E9AFE', '0xFF2E64FE', '0xFFFE2E2E', '0xFFFFD700']]
+
+if __perfil__ < 3:
+    color1, color2, color3, color4, color5 = perfil[__perfil__]
+else:
+    color1 = color2 = color3 = color4 = color5 = ""
+
+__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', __channel__)
+__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', __channel__)
+
+headers = [['User-Agent', 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0'],
+           ['Referer', host]]#,['Accept-Language','it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3']]
+
+parameters = channeltools.get_channel_parameters(__channel__)
+fanart_host = parameters['fanart']
+thumbnail_host = parameters['thumbnail']
+
+IDIOMAS = {'Italiano': 'IT', 'VOSI':'SUB ITA'}
+list_language = IDIOMAS.values()
+# per l'autoplay
+list_servers = ['openload', 'speedvideo', 'wstream', 'streamango' 'flashx', 'nowvideo']
+list_quality = ['default'] 
+
+# =========== home menu ===================
 
 def mainlist(item):
-    logger.info("kod.eurostreaming mainlist")
-    autoplay.init(item.channel, list_servers, list_quality)
+    logger.info("icarus.eurostreaming mainlist")
+    itemlist = []
+    title = ''
 
+    autoplay.init(item.channel, list_servers, list_quality)
+    
     itemlist = [
-        Item(
-            channel=item.channel,
-            title="[B]Serie TV[/B]",
-            action="serietv",
-            extra="tvshow",
+        Item(channel=__channel__, title="Serie TV",
+            contentTitle = __channel__, action="serietv",
+            #extra="tvshow",
+            text_color=color4,
             url="%s/category/serie-tv-archive/" % host,
-            thumbnail=
-            "http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"
-        ),
-        Item(
-            channel=item.channel,
-            title="[B]Anime / Cartoni[/B]",
+            infoLabels={'plot': item.category},
+            thumbnail = get_thumb(title, auto = True)
+            ),
+        Item(channel=__channel__, title="Ultimi Aggiornamenti",
+             contentTitle = __channel__, action="elenco_aggiornamenti_serietv",
+             text_color=color4, url="%saggiornamento-episodi/" % host,
+             #category = __channel__,
+             extra="tvshow",
+             infoLabels={'plot': item.category},
+             thumbnail = get_thumb(title, auto = True)
+             ),        
+        Item(channel=__channel__,
+            title="Anime / Cartoni",
             action="serietv",
             extra="tvshow",
+            text_color=color4,
             url="%s/category/anime-cartoni-animati/" % host,
-            thumbnail=
-            "http://orig09.deviantart.net/df5a/f/2014/169/2/a/fist_of_the_north_star_folder_icon_by_minacsky_saya-d7mq8c8.png"
-        ),
-        Item(
-            channel=item.channel,
-            title="[COLOR blue]Cerca...[/COLOR]",
+            thumbnail= get_thumb(title, auto = True)
+            ),
+        Item(channel=__channel__,
+            title="[COLOR yellow]Cerca...[/COLOR]",
             action="search",
             extra="tvshow",
-            thumbnail=
-            "http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")
+            text_color=color4,
+            thumbnail= get_thumb(title, auto = True)
+            ),
     ]
-
+    
     autoplay.show_option(item.channel, itemlist)
-
-    itemlist = thumb(itemlist)
-
+    
     return itemlist
 
+# ======== def in ordine di menu ===========================
 
 def serietv(item):
-    logger.info("kod.eurostreaming peliculas")
+    
+    logger.info("%s serietv log: %s" % (__channel__, item))
     itemlist = []
-
     # Carica la pagina
     data = httptools.downloadpage(item.url).data
 
@@ -68,29 +122,30 @@ def serietv(item):
     matches = re.compile(patron, re.DOTALL).findall(data)
 
     for scrapedurl, scrapedtitle, scrapedthumbnail in matches:
-        scrapedplot = ""
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.replace("Streaming", ""))
+        #scrapedplot = ""
+        scrapedtitle = scrapertoolsV2.decodeHtmlentities(scrapedtitle)#.replace("Streaming", ""))
         if scrapedtitle.startswith("Link to "):
             scrapedtitle = scrapedtitle[8:]
-        # num = scrapertools.find_single_match(scrapedurl, '(-\d+/)')
-        # if num:
-        #     scrapedurl = scrapedurl.replace(num, "-episodi/")
+        num = scrapertoolsV2.find_single_match(scrapedurl, '(-\d+/)')
+        if num:
+            scrapedurl = scrapedurl.replace(num, "-episodi/")
         itemlist.append(
-            Item(
-                 channel=item.channel,
+            Item(channel=item.channel,
                  action="episodios",
-                 contentType="tvshow",
+                 #contentType="tvshow",
+                 contentSerieName = scrapedtitle,
                  title=scrapedtitle,
-                 fulltitle=scrapedtitle,
-                 text_color="azure",
+                 #text_color="azure",
                  url=scrapedurl,
                  thumbnail=scrapedthumbnail,
-                 plot=scrapedplot,
-                 show=scrapedtitle,
+                 #plot=scrapedplot,
+                 show=item.show,
                  extra=item.extra,
-                 folder=True))
+                 folder=True
+                 ))
 
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    # locandine e trama e altro da tmdb se presente l'anno migliora la ricerca
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True, idioma_busqueda='it')
 
     # Paginazione
     patronvideos = '<a class="next page-numbers" href="?([^>"]+)">Avanti &raquo;</a>'
@@ -102,17 +157,125 @@ def serietv(item):
             Item(
                 channel=item.channel,
                 action="serietv",
-                title="[COLOR blue]" + config.get_localized_string(30992) + "[/COLOR]",
+                title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
                 url=scrapedurl,
-                thumbnail=thumb(),
+                thumbnail=
+                "http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
                 extra=item.extra,
                 folder=True))
 
     return itemlist
 
+def episodios(item):
+    #logger.info("%s episodios log: %s" % (__channel__, item))
+    itemlist = []
+
+    if not(item.lang):
+        lang_season = {'ITA':0, 'SUB ITA' :0}
+        # Download pagina
+        data = httptools.downloadpage(item.url).data
+        #======== 
+        if 'clicca qui per aprire' in data.lower():
+            logger.info("%s CLICCA QUI PER APRIRE GLI EPISODI log: %s" % (__channel__, item))
+            item.url = scrapertoolsV2.find_single_match(data, '"go_to":"(.*?)"')
+            item.url = item.url.replace("\\","")
+            # Carica la pagina
+            data = httptools.downloadpage(item.url).data
+            #logger.info("%s FINE CLICCA QUI PER APRIRE GLI EPISODI log: %s" % (__channel__, item))
+        elif 'clicca qui</span>' in data.lower():
+            logger.info("%s inizio CLICCA QUI</span> log: %s" % (__channel__, item))
+            item.url = scrapertoolsV2.find_single_match(data, '<h2 style="text-align: center;"><a href="(.*?)">')
+            data = httptools.downloadpage(item.url).data
+            #logger.info("%s fine CLICCA QUI</span> log: %s" % (__channel__, item))
+        #=========
+        data = scrapertoolsV2.decodeHtmlentities(data)
+        bloque = scrapertoolsV2.find_single_match(data, '<div class="su-accordion">(.*?)<div class="clear"></div>')
+        patron = '<span class="su-spoiler-icon"></span>(.*?)</div>' 
+        matches = scrapertoolsV2.find_multiple_matches(bloque, patron)
+        for scrapedseason in matches:
+            #logger.info("%s scrapedseason log: %s" % (__channel__, scrapedseason))
+            if "(SUB ITA)" in scrapedseason.upper():
+                lang = "SUB ITA"
+                lang_season['SUB ITA'] +=1
+            else:
+                lang = "ITA"
+                lang_season['ITA'] +=1
+            #logger.info("%s lang_dict log: %s" % (__channel__, lang_season))
+        
+        for lang in sorted(lang_season):
+            if lang_season[lang] > 0:
+                itemlist.append(
+                    Item(channel = item.channel,
+                         action = "episodios",
+                         #contentType = "episode",
+                         contentSerieName = item.title, 
+                         title = '%s (%s)' % (item.title, lang),
+                         url = item.url,
+                         fulltitle = item.title,
+                         data = data,
+                         lang = lang,
+                         show = item.show,
+                         folder = True,
+                         ))
+                
+        # locandine e trama e altro da tmdb se presente l'anno migliora la ricerca
+        tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True, idioma_busqueda='it')
+        
+        return itemlist
+
+    else:
+        # qui ci vanno le puntate delle stagioni
+        html = item.data
+        logger.info("%s else log: [%s]" % (__channel__, item))
+
+        if item.lang == 'SUB ITA':
+            item.lang = '\(SUB ITA\)'
+            logger.info("%s item.lang log: %s" % (__channel__, item.lang))
+        bloque = scrapertoolsV2.find_single_match(html, '<div class="su-accordion">(.*?)<div class="clear"></div>')
+        patron = '<span class="su-spoiler-icon"></span>.*?'+item.lang+'</div>(.*?)</div>' # leggo tutte le stagioni
+        #logger.info("%s patronpatron log: %s" % (__channel__, patron))
+        matches = scrapertoolsV2.find_multiple_matches(bloque, patron)
+        for scrapedseason in matches:
+            #logger.info("%s scrapedseasonscrapedseason log: %s" % (__channel__, scrapedseason))
+            scrapedseason = scrapedseason.replace('<strong>','').replace('</strong>','')
+            patron = '(\d+)×(\d+)(.*?)<(.*?)<br />' # stagione - puntanta - titolo - gruppo link
+            matches = scrapertoolsV2.find_multiple_matches(scrapedseason, patron)
+            for scrapedseason, scrapedpuntata, scrapedtitolo, scrapedgroupurl in matches:
+                #logger.info("%s finale log: %s" % (__channel__, patron))
+                scrapedtitolo = scrapedtitolo.replace('–','')
+                itemlist.append(Item(channel = item.channel,
+                    action = "findvideos",
+                    contentType = "episode",
+                    #contentSerieName = item.contentSerieName,
+                    contentTitle = scrapedtitolo,
+                    title = '%sx%s %s' % (scrapedseason, scrapedpuntata, scrapedtitolo),
+                    url = scrapedgroupurl,
+                    fulltitle = item.fulltitle,
+                    #show = item.show,
+                    #folder = True,
+                    ))
+                    
+        logger.info("%s itemlistitemlist log: %s" % (__channel__, itemlist))
+
+        # Opción "Añadir esta película a la biblioteca de KODI"
+        if item.extra != "library":
+            if config.get_videolibrary_support() and len(itemlist) > 0 and item.extra != 'findvideos':
+                itemlist.append(Item(channel=item.channel, title="%s" % config.get_localized_string(30161),
+                                     text_color="green", extra="episodios",
+                                     action="add_serie_to_library", url=item.url,
+                                     thumbnail= get_thumb('videolibrary', auto = True),
+                                     contentTitle=item.contentSerieName, lang = item.lang,
+                                     show=item.show, data = html
+                                     #, infoLabels = item.infoLabels
+                                     ))
+
+        return itemlist 
+
+# ===========  def ricerca  =============
 def search(item, texto):
-    logger.info("[eurostreaming.py] " + item.url + " search " + texto)
-    item.url = "%s/?s=%s" % (host, texto)
+    #logger.info("[eurostreaming.py] " + item.url + " search " + texto)
+    logger.info("%s search log: %s" % (__channel__, item))
+    item.url = "%s?s=%s" % (host, texto)
     try:
         return serietv(item)
     # Continua la ricerca in caso di errore
@@ -122,116 +285,122 @@ def search(item, texto):
             logger.error("%s" % line)
         return []
 
-
-def episodios(item):
-    def load_episodios(html, item, itemlist, lang_title):
-        patron = '((?:.*?<a[^h]+href="[^"]+"[^>]+>[^<][^<]+<(?:b|\/)[^>]+>)+)'
-        matches = re.compile(patron).findall(html)
-        for data in matches:
-            # Estrazione
-
-            scrapedtitle = data.split('<a ')[0]
-            scrapedtitle = re.sub(r'<[^>]*>', '', scrapedtitle).strip()
-            if scrapedtitle != 'Categorie':
-                scrapedtitle = scrapedtitle.replace('&#215;', 'x')
-                scrapedtitle = scrapedtitle.replace('×', 'x')
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action="findvideos",
-                         contentType="episode",
-                         title="[COLOR azure]%s[/COLOR]" % (scrapedtitle + " (" + lang_title + ")"),
-                         url=data,
-                         thumbnail=item.thumbnail,
-                         extra=item.extra,
-                         fulltitle=scrapedtitle + " (" + lang_title + ")" + ' - ' + item.show,
-                         show=item.show))
-
-    logger.info("[eurostreaming.py] episodios")
-
+# ===========  def novità in ricerca globale  =============
+def newest(categoria):
+    logger.info("%s newest log: %s" % (__channel__, categoria))
     itemlist = []
+    item = Item()
+    try:
+    
+        item.url = "%saggiornamento-episodi/" % host
+        item.action = "elenco_aggiornamenti_serietv"
+        itemlist = elenco_aggiornamenti_serietv(item)
 
-    # Download pagina
-    data = httptools.downloadpage(item.url).data
-    data = scrapertools.decodeHtmlentities(data)
-    link = False
+        if itemlist[-1].action == "elenco_aggiornamenti_serietv":
+            itemlist.pop()
 
-    if scrapertoolsV2.find_single_match(data, '<div class="nano_cp_container"><span.*?CLICCA QUI'):
-        item.url = scrapertoolsV2.find_single_match(data, '<script type="text\/javascript">.*?var nano_ajax_object =.*?"go_to":"(.*?)"').replace('\\', '')
-        link = True
-    else:
-        match = scrapertoolsV2.find_single_match(data, '<h3 style="text-align: center;">.*?<a href="(.*?)">.{0,5}<span.*?CLICCA QUI.*?</a></h3>')
-        if match != '':
-            item.url = match
-            link = True
-    if link:
-        data = httptools.downloadpage(item.url).data
-        data = scrapertools.decodeHtmlentities(data)
-
-    data = scrapertoolsV2.find_single_match(data, '<div class="su-accordion">(.+?)<div class="clear">')
-
-    lang_titles = []
-    starts = []
-    patron = r"STAGIONE.*?ITA"
-    matches = re.compile(patron, re.IGNORECASE).finditer(data)
-
-    for match in matches:
-        season_title = match.group()
-
-        if season_title != '':
-            lang_titles.append('SUB ITA' if 'SUB' in season_title.upper() else 'ITA')
-            starts.append(match.end())
-
-    i = 1
-    len_lang_titles = len(lang_titles)
-
-    while i <= len_lang_titles:
-        inizio = starts[i - 1]
-        fine = starts[i] if i < len_lang_titles else -1
-
-        html = data[inizio:fine]
-        lang_title = lang_titles[i - 1]
-
-        load_episodios(html, item, itemlist, lang_title)
-
-        i += 1
-
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
+    # Continua la ricerca in caso di errore 
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
 
     return itemlist
 
+# ===========  def pagina aggiornamenti  =============
+
+# ======== Ultimi Aggiornamenti ===========================
+def elenco_aggiornamenti_serietv(item):
+    """
+    def per la lista degli aggiornamenti
+    """
+    logger.info("%s elenco_aggiornamenti_serietv log: %s" % (__channel__, item))
+    itemlist = []
+
+    # Carica la pagina
+    data = httptools.downloadpage(item.url).data
+
+    # Estrae i contenuti
+    #bloque = scrapertoolsV2.get_match(data, '<div class="entry">(.*?)<div class="clear"></div>')
+    bloque = scrapertoolsV2.find_single_match(data, '<div class="entry">(.*?)<div class="clear"></div>')
+    patron = '<span class="serieTitle".*?>(.*?)<.*?href="(.*?)".*?>(.*?)<'
+    matches = scrapertoolsV2.find_multiple_matches(bloque, patron)
+
+    for scrapedtitle, scrapedurl, scrapedepisodies in matches:
+        if "(SUB ITA)" in scrapedepisodies.upper():
+            lang = "SUB ITA"
+            scrapedepisodies = scrapedepisodies.replace('(SUB ITA)','')
+        else:
+            lang = "ITA"
+            scrapedepisodies = scrapedepisodies.replace(lang,'')
+        #num = scrapertoolsV2.find_single_match(scrapedepisodies, '(-\d+/)')
+        #if num:
+        #    scrapedurl = scrapedurl.replace(num, "-episodi/")
+        scrapedtitle = scrapedtitle.replace("–", "").replace('\xe2\x80\x93 ','').strip()
+        scrapedepisodies = scrapedepisodies.replace('\xe2\x80\x93 ','').strip()
+        itemlist.append(
+            Item(
+                 channel=item.channel,
+                 action="episodios",
+                 contentType="tvshow",
+                 title = "%s" % scrapedtitle, # %s" % (scrapedtitle, scrapedepisodies),
+                 fulltitle = "%s %s" % (scrapedtitle, scrapedepisodies),
+                 text_color = color5,
+                 url = scrapedurl,
+                 #show = "%s %s" % (scrapedtitle, scrapedepisodies),
+                 extra=item.extra,
+                 #lang = lang,
+                 #data = data,
+                 folder=True))
+
+    # locandine e trama e altro da tmdb se presente l'anno migliora la ricerca
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True, idioma_busqueda='it')
+
+    return itemlist
+
+# ===========  def per trovare i video  =============
 
 def findvideos(item):
-    logger.info("kod.eurostreaming findvideos")
+    logger.info("%s findvideos log: %s" % (__channel__, item))
     itemlist = []
 
     # Carica la pagina 
     data = item.url
 
-    matches = re.findall(r'<a href="([^"]+)"[^>]*>[^<]+</a>', data, re.DOTALL)
+    matches = re.findall(r'a href="([^"]+)"[^>]*>[^<]+</a>', data, re.DOTALL)
 
     data = []
     for url in matches:
         url, c = unshortenit.unshorten(url)
         data.append(url)
 
-    itemlist = servertools.find_video_items(data=str(data))
+    try:
+        itemlist = servertools.find_video_items(data=str(data))
 
-    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 = item.channel
-        videoitem.contentType = item.contentType
+        for videoitem in itemlist:
+            logger.info("Videoitemlist2: %s" % videoitem)
+            videoitem.title = "%s [%s]" % (item.contentTitle, videoitem.title)#"[%s] %s" % (videoitem.server, item.title) #"[%s]" % (videoitem.title)
+            videoitem.show = item.show
+            videoitem.contentTitle = item.contentTitle
+            videoitem.contentType = item.contentType
+            videoitem.channel = item.channel
+            videoitem.text_color = color5
+            #videoitem.language = item.language
+            videoitem.year = item.infoLabels['year']
+            videoitem.infoLabels['plot'] = item.infoLabels['plot']
+    except AttributeError:
+        logger.error("data doesn't contain expected URL")
 
+    # Controlla se i link sono validi
+    if __comprueba_enlaces__:
+        itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
+
+    # Requerido para FilterTools
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    # Requerido para AutoPlay
     autoplay.start(itemlist, item)
 
+
     return itemlist
diff --git a/platformcode/unify.py b/platformcode/unify.py
index 40db14af..657df0d6 100644
--- a/platformcode/unify.py
+++ b/platformcode/unify.py
@@ -17,119 +17,152 @@ from core.item import Item
 from core import scrapertools
 from platformcode import logger
 
-thumb_dict = {"movies": "https://s10.postimg.cc/fxtqzdog9/peliculas.png",
-    "tvshows": "https://s10.postimg.cc/kxvslawe1/series.png",
-    "all": "https://s10.postimg.cc/h1igpgw0p/todas.png",
-    "genres": "https://s10.postimg.cc/6c4rx3x1l/generos.png",
-    "search": "https://s10.postimg.cc/v985e2izd/buscar.png",
-    "quality": "https://s10.postimg.cc/9bbojsbjd/calidad.png",
-    "audio": "https://s10.postimg.cc/b34nern7d/audio.png",
-    "newest": "https://s10.postimg.cc/g1s5tf1bt/novedades.png",
-    "last": "https://s10.postimg.cc/i6ciuk0eh/ultimas.png",
-    "hot": "https://s10.postimg.cc/yu40x8q2x/destacadas.png",
-    "year": "https://s10.postimg.cc/atzrqg921/a_o.png",
-    "alphabet": "https://s10.postimg.cc/4dy3ytmgp/a-z.png",
-    "recomended": "https://s10.postimg.cc/7xk1oqccp/recomendadas.png",
-    "more watched": "https://s10.postimg.cc/c6orr5neh/masvistas.png",
-    "more voted": "https://s10.postimg.cc/lwns2d015/masvotadas.png",
-    "favorites": "https://s10.postimg.cc/rtg147gih/favoritas.png",
-    "colections": "https://s10.postimg.cc/ywnwjvytl/colecciones.png",
-    "categories": "https://s10.postimg.cc/v0ako5lmh/categorias.png",
-    "premieres": "https://s10.postimg.cc/sk8r9xdq1/estrenos.png",
-    "documentaries": "https://s10.postimg.cc/68aygmmcp/documentales.png",
-    "language": "https://s10.postimg.cc/6wci189ft/idioma.png",
-    "new episodes": "https://s10.postimg.cc/fu4iwpnqh/nuevoscapitulos.png",
-    "country": "https://s10.postimg.cc/yz0h81j15/pais.png",
-    "adults": "https://s10.postimg.cc/s8raxc51l/adultos.png",
-    "recents": "https://s10.postimg.cc/649u24kp5/recents.png",
-    "updated" : "https://s10.postimg.cc/46m3h6h9l/updated.png",
-    "actors": "https://i.postimg.cc/tC2HMhVV/actors.png",
-    "cast": "https://i.postimg.cc/qvfP5Xvt/cast.png",
-    "lat": "https://i.postimg.cc/Gt8fMH0J/lat.png",
-    "vose": "https://i.postimg.cc/kgmnbd8h/vose.png",
+thumb_dict = {
+    "numbers": "http://icons.iconarchive.com/icons/custom-icon-design/pretty-office-10/256/Numbers-icon.png",
+    "a": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-A-black-icon.png",
     "accion": "https://s14.postimg.cc/sqy3q2aht/action.png",
+    "actors": "https://i.postimg.cc/tC2HMhVV/actors.png",
     "adolescente" : "https://s10.postimg.cc/inq7u4p61/teens.png",
     "adultos": "https://s10.postimg.cc/s8raxc51l/adultos.png",
+    "adults": "https://s10.postimg.cc/s8raxc51l/adultos.png",
+    "alcinema": "http://icons.iconarchive.com/icons/chromatix/aerial/256/movie-icon.png", #"http://icons.iconarchive.com/icons/itzikgur/my-seven/256/Movies-Films-icon.png",
+    "all": "https://s10.postimg.cc/h1igpgw0p/todas.png",
+    "alphabet": "https://s10.postimg.cc/4dy3ytmgp/a-z.png",
     "animacion": "https://s14.postimg.cc/vl193mupd/animation.png",
     "anime" : "https://s10.postimg.cc/n9mc2ikzt/anime.png",
     "artes marciales" : "https://s10.postimg.cc/4u1v51tzt/martial_arts.png",
     "asiaticas" : "https://i.postimg.cc/Xq0HXD5d/asiaticas.png",
-    "aventura": "https://s14.postimg.cc/ky7fy5he9/adventure.png",
+    "audio": "https://s10.postimg.cc/b34nern7d/audio.png",
+    "aventura": "http://icons.iconarchive.com/icons/sirubico/movie-genre/256/Adventure-2-icon.png",#"https://s14.postimg.cc/ky7fy5he9/adventure.png",
+    "b": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-B-black-icon.png",
     "belico": "https://s14.postimg.cc/5e027lru9/war.png",
     "biografia" : "https://s10.postimg.cc/jq0ecjxnt/biographic.png",
+    "c": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-C-black-icon.png",
     "carreras": "https://s14.postimg.cc/yt5qgdr69/races.png",
+    "cast": "https://i.postimg.cc/qvfP5Xvt/cast.png",
+    "categories": "https://s10.postimg.cc/v0ako5lmh/categorias.png",
     "ciencia ficcion": "https://s14.postimg.cc/8kulr2jy9/scifi.png",
     "cine negro" : "https://s10.postimg.cc/6ym862qgp/noir.png",
+    "colections": "https://s10.postimg.cc/ywnwjvytl/colecciones.png",
     "comedia": "https://s14.postimg.cc/9ym8moog1/comedy.png",
     "cortometraje" : "https://s10.postimg.cc/qggvlxndl/shortfilm.png",
+    "country": "https://s10.postimg.cc/yz0h81j15/pais.png",
     "crimen": "https://s14.postimg.cc/duzkipjq9/crime.png",
+    "d": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-D-black-icon.png",
     "de la tv": "https://s10.postimg.cc/94gj0iwh5/image.png",
     "deporte": "https://s14.postimg.cc/x1crlnnap/sports.png",
     "destacadas": "https://s10.postimg.cc/yu40x8q2x/destacadas.png",
     "documental": "https://s10.postimg.cc/68aygmmcp/documentales.png",
+    "documentaries": "https://s10.postimg.cc/68aygmmcp/documentales.png",
     "doramas":"https://s10.postimg.cc/h4dyr4nfd/doramas.png",
     "drama": "https://s14.postimg.cc/fzjxjtnxt/drama.png",
+    "e": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-E-black-icon.png",
     "erotica" : "https://s10.postimg.cc/dcbb9bfx5/erotic.png",
     "espanolas" : "https://s10.postimg.cc/x1y6zikx5/spanish.png",
     "estrenos" : "https://s10.postimg.cc/sk8r9xdq1/estrenos.png",
     "extranjera": "https://s10.postimg.cc/f44a4eerd/foreign.png",
+    "f": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-F-black-icon.png",
     "familiar": "https://s14.postimg.cc/jj5v9ndsx/family.png",
     "fantasia": "https://s14.postimg.cc/p7c60ksg1/fantasy.png",
     "fantastico" : "https://s10.postimg.cc/tedufx5eh/fantastic.png",
+    "favorites": "https://s10.postimg.cc/rtg147gih/favoritas.png",
+    "g": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-G-black-icon.png",
+    "genres": "https://s10.postimg.cc/6c4rx3x1l/generos.png",
+    "h": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-H-black-icon.png",
     "historica": "https://s10.postimg.cc/p1faxj6yh/historic.png",
     "horror" : "https://s10.postimg.cc/8exqo6yih/horror2.png",
+    "hot": "https://s10.postimg.cc/yu40x8q2x/destacadas.png",
+    "i": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-I-black-icon.png",
     "infantil": "https://s14.postimg.cc/4zyq842mp/childish.png",
     "intriga": "https://s14.postimg.cc/5qrgdimw1/intrigue.png",
+    "j": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-J-black-icon.png",
+    "k": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-K-black-icon.png",
+    "l": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-L-black-icon.png",
+    "language": "https://s10.postimg.cc/6wci189ft/idioma.png",
+    "last": "https://s10.postimg.cc/i6ciuk0eh/ultimas.png",
+    "lat": "https://i.postimg.cc/Gt8fMH0J/lat.png",
     "latino" : "https://s10.postimg.cc/swip0b86h/latin.png",
+    "m": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-M-black-icon.png",
     "mexicanas" : "https://s10.postimg.cc/swip0b86h/latin.png",
     "misterio": "https://s14.postimg.cc/3m73cg8ep/mistery.png",
+    "more voted": "https://s10.postimg.cc/lwns2d015/masvotadas.png",
+    "more watched": "https://s10.postimg.cc/c6orr5neh/masvistas.png",
+    "movies": "https://s10.postimg.cc/fxtqzdog9/peliculas.png",
     "musical": "https://s10.postimg.cc/hy7fhtecp/musical.png",
+    "n": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-N-black-icon.png",
+    "new episodes": "https://s10.postimg.cc/fu4iwpnqh/nuevoscapitulos.png",
+    "newest": "http://icons.iconarchive.com/icons/laurent-baumann/creme/128/Location-News-icon.png", #"http://icons.iconarchive.com/icons/uiconstock/ios8-setting/128/news-icon.png",
+    "nextpage": "http://icons.iconarchive.com/icons/custom-icon-design/pretty-office-5/256/navigate-right-icon.png", #"http://icons.iconarchive.com/icons/custom-icon-design/office/256/forward-icon.png", #"http://icons.iconarchive.com/icons/ahmadhania/spherical/128/forward-icon.png",
+    "o": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-O-black-icon.png",
+    "others": "http://icons.iconarchive.com/icons/limav/movie-genres-folder/128/Others-icon.png",
+    "p": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-P-black-icon.png",
     "peleas" : "https://s10.postimg.cc/7a3ojbjwp/Fight.png",
     "policial" : "https://s10.postimg.cc/wsw0wbgbd/cops.png",
+    "premieres": "https://s10.postimg.cc/sk8r9xdq1/estrenos.png",
+    "q": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-Q-black-icon.png",
+    "quality": "https://s10.postimg.cc/9bbojsbjd/calidad.png",
+    "r": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-R-black-icon.png",
+    "recents": "https://s10.postimg.cc/649u24kp5/recents.png",
     "recomendadas": "https://s10.postimg.cc/7xk1oqccp/recomendadas.png",
+    "recomended": "https://s10.postimg.cc/7xk1oqccp/recomendadas.png",
     "religion" : "https://s10.postimg.cc/44j2skquh/religion.png",
     "romance" : "https://s10.postimg.cc/yn8vdll6x/romance.png",
     "romantica": "https://s14.postimg.cc/8xlzx7cht/romantic.png",
+    "s": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-S-black-icon.png",
+    "search": "http://icons.iconarchive.com/icons/jamespeng/movie/256/database-icon.png",
     "suspenso": "https://s10.postimg.cc/7peybxdfd/suspense.png",
+    "t": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-T-black-icon.png",
     "telenovelas": "https://i.postimg.cc/QCXZkyDM/telenovelas.png",
     "terror": "https://s14.postimg.cc/thqtvl52p/horror.png",
     "thriller": "https://s14.postimg.cc/uwsekl8td/thriller.png",
-    "western": "https://s10.postimg.cc/5wc1nokjt/western.png"
+    "tvshows": "https://s10.postimg.cc/kxvslawe1/series.png",
+    "u": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-U-black-icon.png",
+    "ultimiarrivi" : "http://icons.iconarchive.com/icons/saki/snowish/128/Extras-internet-download-icon.png",
+    "updated" : "https://s10.postimg.cc/46m3h6h9l/updated.png",
+    "v": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-V-black-icon.png",
+    "vose": "https://i.postimg.cc/kgmnbd8h/vose.png",
+    "w": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-W-black-icon.png",
+    "western": "https://s10.postimg.cc/5wc1nokjt/western.png",
+    "x": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-X-black-icon.png",
+    "y": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-Y-black-icon.png",
+    "year": "https://s10.postimg.cc/atzrqg921/a_o.png",
+    "z": "http://icons.iconarchive.com/icons/hydrattz/multipurpose-alphabet/256/Letter-Z-black-icon.png"
     }
 
 def set_genre(string):
     #logger.info()
 
-    genres_dict = {'accion':['accion', 'action', 'accion y aventura', 'action & adventure'],
-                   'adultos':['adultos', 'adultos +', 'adulto'],
-                   'animacion':['animacion', 'animacion e infantil', 'dibujos animados'],
-                   'adolescente':['adolescente', 'adolescentes', 'adolescencia', 'adolecentes'],
-                   'aventura':['aventura', 'aventuras'],
-                   'belico':['belico', 'belica', 'belicas', 'guerra', 'belico guerra'],
-                   'biografia':['biografia', 'biografias', 'biografica', 'biograficas', 'biografico'],
+    genres_dict = {'accion':['azione'],
+                   'adultos':['adulto','adulti'],
+                   'animacion':['animazione'],   
+                   'adolescente':['adolescente', 'adolescenti'],
+                   'aventura':['avventura'],
+                   'belico':['guerra','guerriglia'],
+                   'biografia':['biografia', 'biografie', 'biografico'],
                    'ciencia ficcion':['ciencia ficcion', 'cienciaficcion', 'sci fi', 'c ficcion'],
-                   'cine negro':['film noir', 'negro'],
-                   'comedia':['comedia', 'comedias'],
-                   'cortometraje':['cortometraje', 'corto', 'cortos'],
-                   'de la tv':['de la tv', 'television', 'tv'],
+                   'cine negro':['film noir'],
+                   'comedia':['commedia', 'commedie'],
+                   'cortometraje':['cortometraggio', 'corto', 'corti'],
+                   'de la tv':['della tv', 'televisione', 'tv'],
                    'deporte':['deporte', 'deportes'],
                    'destacadas':['destacada', 'destacadas'],
-                   'documental':['documental', 'documentales'],
+                   'documental':['documentario', 'documentari'],
                    'erotica':['erotica', 'erotica +', 'eroticas', 'eroticas +', 'erotico', 'erotico +'],
                    'estrenos':['estrenos', 'estrenos'],
                    'extranjera':['extrajera', 'extrajeras', 'foreign'],
-                   'familiar':['familiar', 'familia'],
-                   'fantastico':['fantastico', 'fantastica', 'fantasticas'],
-                   'historica':['historica', 'historicas', 'historico', 'historia'],
-                   'infantil':['infantil', 'kids'],
-                   'musical':['musical', 'musicales', 'musica'],
-                   'policial':['policial', 'policiaco', 'policiaca'],
-                   'recomendadas':['recomedada', 'recomendadas'],
-                   'religion':['religion', 'religiosa', 'religiosas'],
-                   'romantica':['romantica', 'romanticas', 'romantico'],
+                   'familiar':['familiare', 'famiglia'],
+                   'fantastico':['fantastico', 'fantastica', 'fantastici'],
+                   'historica':['storico', 'storia'],
+                   'infantil':['bambini', 'infanzia'],
+                   'musical':['musicale', 'musical', 'musica'],
+                   'numbers': ['0','1','2','3','4','5','6','7','8','9'],
+                   'policial':['politico', 'politici', 'politica'],
+                   'recomendadas':['raccomandato', 'raccomandati'],
+                   'religion':['religione', 'religioso', 'religiosa','religiosi'],
+                   'romantica':['romantica', 'romantico', 'romantici'],
                    'suspenso':['suspenso', 'suspense'],
                    'thriller':['thriller', 'thrillers'],
-                   'western':['western', 'westerns', 'oeste western']
+                   'western':['western', 'westerns']
                    }
     string = re.sub(r'peliculas de |pelicula de la |peli |cine ','', string)
     for genre, variants in genres_dict.items():

From 1c61348979c2dc840865c54841a2e49d7f420e95 Mon Sep 17 00:00:00 2001
From: 4l3x87 <50104109+4l3x87@users.noreply.github.com>
Date: Fri, 3 May 2019 19:44:50 +0200
Subject: [PATCH 14/23] Add SerieTVU and Serie Tv Sub Ita Channel (#5)

* Add SerieTVU Channel

* SerieTVU Channel
- config host
- new menu

* SerieTVU Channel - fix

* Add Serie Tv Sub Ita Channel
Fix gounlimited regex

* Serie Tv Sub Ita - remove videolibrary support

* SerieTVU - fix videolibary tvshow

* Serie Tv Sub Ita disabled
Add Credit comment
---
 channels/serietvsubita.json |  44 +++++
 channels/serietvsubita.py   | 352 ++++++++++++++++++++++++++++++++++++
 channels/serietvu.json      |  44 +++++
 channels/serietvu.py        | 296 ++++++++++++++++++++++++++++++
 servers/gounlimited.json    |   2 +-
 5 files changed, 737 insertions(+), 1 deletion(-)
 create mode 100644 channels/serietvsubita.json
 create mode 100644 channels/serietvsubita.py
 create mode 100644 channels/serietvu.json
 create mode 100644 channels/serietvu.py

diff --git a/channels/serietvsubita.json b/channels/serietvsubita.json
new file mode 100644
index 00000000..4dd01090
--- /dev/null
+++ b/channels/serietvsubita.json
@@ -0,0 +1,44 @@
+{
+    "id": "serietvsubita",
+    "name": "Serie TV Sub ITA",
+    "active": false,
+    "adult": false,
+    "language": ["ita"],
+    "thumbnail": "http://serietvsubita.xyz/wp-content/uploads/2012/07/logo.jpg",
+    "banner": "http://serietvsubita.xyz/wp-content/uploads/2012/07/logo.jpg",
+    "categories": ["tvshow"],
+    "settings": [
+        {
+            "id": "channel_host",
+            "type": "text",
+            "label": "Host del canale",
+            "default": "http://serietvsubita.xyz/",
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "include_in_global_search",
+            "type": "bool",
+            "label": "Includi ricerca globale",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },    
+        {
+            "id": "include_in_newest_series",
+            "type": "bool",
+            "label": "Includi in Novità - Serie TV",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "include_in_newest_italiano",
+            "type": "bool",
+            "label": "Includi in Novità - Italiano",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        }
+    ]
+}
diff --git a/channels/serietvsubita.py b/channels/serietvsubita.py
new file mode 100644
index 00000000..ff2d3381
--- /dev/null
+++ b/channels/serietvsubita.py
@@ -0,0 +1,352 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Serie Tv Sub ITA
+# Ringraziamo Icarus crew
+# ----------------------------------------------------------
+import inspect
+import re
+import time
+
+import channelselector
+from channels import autoplay, support, filtertools
+from core import httptools, tmdb, scrapertools
+from core.item import Item
+from platformcode import logger, config
+
+host = config.get_setting("channel_host", 'serietvsubita')
+headers = [['Referer', host]]
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+list_servers = ['gounlimited','verystream','streamango','openload']
+list_quality = ['default']
+
+
+
+def mainlist(item):
+    support.log(item.channel + 'mainlist')
+    itemlist = []
+    support.menu(itemlist, 'Serie TV bold', 'lista_serie', host,'tvshow')
+    support.menu(itemlist, 'Novità submenu', 'peliculas_tv', host,'tvshow')
+    support.menu(itemlist, 'Archivio A-Z submenu', 'list_az', host,'tvshow')
+    support.menu(itemlist, 'Cerca', 'search', host,'tvshow')
+
+
+    autoplay.init(item.channel, list_servers, list_quality)
+    autoplay.show_option(item.channel, itemlist)
+
+    itemlist.append(
+        Item(channel='setting',
+             action="channel_config",
+             title=support.typo("Configurazione Canale color lime"),
+             config=item.channel,
+             folder=False,
+             thumbnail=channelselector.get_thumb('setting_0.png'))
+    )
+
+    return itemlist
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def cleantitle(scrapedtitle):
+    scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
+    scrapedtitle = scrapedtitle.replace('[HD]', '').replace('’', '\'').replace('Game of Thrones –','')
+    year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
+    if year:
+        scrapedtitle = scrapedtitle.replace('(' + year + ')', '')
+
+
+    return scrapedtitle.strip()
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def lista_serie(item):
+    support.log(item.channel + " lista_serie")
+    itemlist = []
+
+    PERPAGE = 15
+
+    p = 1
+    if '{}' in item.url:
+        item.url, p = item.url.split('{}')
+        p = int(p)
+
+    # Descarga la pagina
+    data = httptools.downloadpage(item.url).data
+
+    # Extrae las entradas
+    patron = '<li class="cat-item cat-item-\d+"><a href="([^"]+)" >([^<]+)</a>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
+        scrapedplot = ""
+        scrapedthumbnail = ""
+        if (p - 1) * PERPAGE > i: continue
+        if i >= p * PERPAGE: break
+        title = cleantitle(scrapedtitle)
+        itemlist.append(
+            Item(channel=item.channel,
+                 extra=item.extra,
+                 action="episodes",
+                 title=title,
+                 url=scrapedurl,
+                 thumbnail=scrapedthumbnail,
+                 fulltitle=title,
+                 show=title,
+                 plot=scrapedplot,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazione
+    if len(matches) >= p * PERPAGE:
+        scrapedurl = item.url + '{}' + str(p + 1)
+        itemlist.append(
+            Item(channel=item.channel,
+                 action='lista_serie',
+                 contentType=item.contentType,
+                 title=support.typo(config.get_localized_string(30992), 'color kod bold'),
+                 url=scrapedurl,
+                 args=item.args,
+                 thumbnail=support.thumb()))
+
+    return itemlist
+
+# ================================================================================================================
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def episodes(item):
+    support.log(item.channel + " episodes")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url).data
+
+    patron = '<div class="post-meta">\s*<a href="([^"]+)"\s*title="([^"]+)"\s*class=".*?"></a>.*?'
+    patron += '<p><a href="([^"]+)">'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedtitle, scrapedthumbnail in matches:
+        scrapedplot = ""
+        scrapedtitle = cleantitle(scrapedtitle)
+        title = scrapedtitle.split(" S0")[0].strip()
+        title = title.split(" S1")[0].strip()
+        title = title.split(" S2")[0].strip()
+
+        itemlist.append(
+            Item(channel=item.channel,
+                 extra=item.extra,
+                 action="findvideos",
+                 fulltitle=scrapedtitle,
+                 show=scrapedtitle,
+                 title=scrapedtitle,
+                 url=scrapedurl,
+                 thumbnail=scrapedthumbnail,
+                 plot=scrapedplot,
+                 contentSerieName=title,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazionazione
+    patron = '<strong class=\'on\'>\d+</strong>\s*<a href="([^<]+)">\d+</a>'
+    next_page = scrapertools.find_single_match(data, patron)
+    if next_page != "":
+        itemlist.append(
+            Item(channel=item.channel,
+                 action='episodes',
+                 contentType=item.contentType,
+                 title=support.typo(config.get_localized_string(30992), 'color kod bold'),
+                 url=next_page,
+                 args=item.args,
+                 thumbnail=support.thumb()))
+
+    # support.videolibrary(itemlist,item,'bold color kod')
+
+    return itemlist
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def findvideos(item):
+    support.log(item.channel + " findvideos")
+
+    data = httptools.downloadpage(item.url).data
+
+    patron = 'href="(https?://www\.keeplinks\.(?:co|eu)/p(?:[0-9]*)/([^"]+))"'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    for keeplinks, id in matches:
+        headers = [['Cookie', 'flag[' + id + ']=1; defaults=1; nopopatall=' + str(int(time.time()))],
+                   ['Referer', keeplinks]]
+
+        html = httptools.downloadpage(keeplinks, headers=headers).data
+        data += str(scrapertools.find_multiple_matches(html, '</lable><a href="([^"]+)" target="_blank"'))
+
+    itemlist = support.server(item, data=data)
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    autoplay.start(itemlist, item)
+
+    return itemlist
+
+# ================================================================================================================
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def peliculas_tv(item):
+    logger.info("icarus serietvsubita peliculas_tv")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url).data
+    logger.debug(data)
+    patron = '<div class="post-meta">\s*<a href="([^"]+)"\s*title="([^"]+)"\s*class=".*?"></a>'
+
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedurl, scrapedtitle in matches:
+        if "FACEBOOK" in scrapedtitle or "RAPIDGATOR" in scrapedtitle:
+            continue
+        if scrapedtitle == "WELCOME!":
+            continue
+        scrapedthumbnail = ""
+        scrapedplot = ""
+        scrapedtitle = cleantitle(scrapedtitle)
+        title = scrapedtitle.split(" S0")[0].strip()
+        title = title.split(" S1")[0].strip()
+        title = title.split(" S2")[0].strip()
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="findvideos",
+                 fulltitle=scrapedtitle,
+                 show=scrapedtitle,
+                 title=scrapedtitle,
+                 url=scrapedurl,
+                 thumbnail=scrapedthumbnail,
+                 contentSerieName=title,
+                 plot=scrapedplot,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+
+    # Paginazione
+    patron = '<strong class=\'on\'>\d+</strong>\s*<a href="([^<]+)">\d+</a>'
+    next_page = scrapertools.find_single_match(data, patron)
+    if next_page != "":
+        if item.extra == "search_tv":
+            next_page = next_page.replace('&#038;', '&')
+        itemlist.append(
+            Item(channel=item.channel,
+                 action='peliculas_tv',
+                 contentType=item.contentType,
+                 title=support.typo(config.get_localized_string(30992), 'color kod bold'),
+                 url=next_page,
+                 args=item.args,
+                 extra=item.extra,
+                 thumbnail=support.thumb()))
+
+
+    return itemlist
+
+
+# ================================================================================================================
+
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def newest(categoria):
+    logger.info('serietvsubita' + " newest" + categoria)
+    itemlist = []
+    item = Item()
+    item.url = host;
+    item.extra = 'serie';
+    try:
+        if categoria == "series":
+            itemlist = peliculas_tv(item)
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def search(item, texto):
+    logger.info(item.channel + " search")
+    itemlist = []
+    item.extra = "search_tv"
+
+    item.url = host + "/?s=" + texto + "&op.x=0&op.y=0"
+
+    try:
+        return peliculas_tv(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("%s" % line)
+        return []
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def list_az(item):
+    support.log(item.channel+" list_az")
+    itemlist = []
+    PERPAGE = 50
+
+    p = 1
+    if '{}' in item.url:
+        item.url, p = item.url.split('{}')
+        p = int(p)
+
+    # Scarico la pagina
+    data = httptools.downloadpage(item.url).data
+
+    # Articoli
+    patron = '<li class="cat-item cat-item-\d+"><a href="([^"]+)" >([^<]+)</a>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
+        scrapedplot = ""
+        scrapedthumbnail = ""
+        if (p - 1) * PERPAGE > i: continue
+        if i >= p * PERPAGE: break
+        title = cleantitle(scrapedtitle)
+        itemlist.append(
+            Item(channel=item.channel,
+                 extra=item.extra,
+                 action="episodes",
+                 title=title,
+                 url=scrapedurl,
+                 fulltitle=title,
+                 show=title,
+                 plot=scrapedplot,
+                 folder=True))
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Paginazione
+    if len(matches) >= p * PERPAGE:
+        scrapedurl = item.url + '{}' + str(p + 1)
+        itemlist.append(
+            Item(channel=item.channel,
+                 action='list_az',
+                 contentType=item.contentType,
+                 title=support.typo(config.get_localized_string(30992), 'color kod bold'),
+                 url=scrapedurl,
+                 args=item.args,
+                 extra=item.extra,
+                 thumbnail=support.thumb()))
+
+    return itemlist
+
+# ================================================================================================================
diff --git a/channels/serietvu.json b/channels/serietvu.json
new file mode 100644
index 00000000..b598e9ab
--- /dev/null
+++ b/channels/serietvu.json
@@ -0,0 +1,44 @@
+{
+    "id": "serietvu",
+    "name": "SerieTVU",
+    "active": true,
+    "adult": false,
+    "language": ["ita"],
+    "thumbnail": "https://www.serietvu.club/wp-content/themes/gurarjbar/images/logo.png",
+    "banner": "https://www.serietvu.club/wp-content/themes/gurarjbar/images/logo.png",
+    "categories": ["tvshow"],
+    "settings": [
+        {
+            "id": "channel_host",
+            "type": "text",
+            "label": "Host del canale",
+            "default": "https://www.serietvu.club",
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "include_in_global_search",
+            "type": "bool",
+            "label": "Includi ricerca globale",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },    
+        {
+            "id": "include_in_newest_series",
+            "type": "bool",
+            "label": "Includi in Novità - Serie TV",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "include_in_newest_italiano",
+            "type": "bool",
+            "label": "Includi in Novità - Italiano",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        }
+    ]
+}
diff --git a/channels/serietvu.py b/channels/serietvu.py
new file mode 100644
index 00000000..225fc6dd
--- /dev/null
+++ b/channels/serietvu.py
@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per SerieTVU
+# Ringraziamo Icarus crew
+# ----------------------------------------------------------
+import re
+
+import channelselector
+from channels import autoplay, support, filtertools
+from core import httptools, tmdb, scrapertools
+from core.item import Item
+from platformcode import logger, config
+
+host = config.get_setting("channel_host", 'serietvu')
+headers = [['Referer', host]]
+
+IDIOMAS = {'Italiano': 'IT'}
+list_language = IDIOMAS.values()
+list_servers = ['speedvideo']
+list_quality = ['default']
+
+
+
+def mainlist(item):
+    support.log(item.channel + 'mainlist')
+    itemlist = []
+    support.menu(itemlist, 'Serie TV bold', 'lista_serie', "%s/category/serie-tv" % host,'tvshow')
+    support.menu(itemlist, 'Novità submenu', 'latestep', "%s/ultimi-episodi" % host,'tvshow')
+    # support.menu(itemlist, 'Nuove serie color azure', 'lista_serie', "%s/category/serie-tv" % host,'tvshow')
+    support.menu(itemlist, 'Categorie', 'categorie', host,'tvshow')
+    support.menu(itemlist, 'Cerca', 'search', host,'tvshow')
+
+
+    # autoplay.init(item.channel, list_servers, list_quality)
+    # autoplay.show_option(item.channel, itemlist)
+
+    itemlist.append(
+        Item(channel='setting',
+             action="channel_config",
+             title=support.typo("Configurazione Canale color lime"),
+             config=item.channel,
+             folder=False,
+             thumbnail=channelselector.get_thumb('setting_0.png'))
+    )
+
+    return itemlist
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def cleantitle(scrapedtitle):
+    scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
+    scrapedtitle = scrapedtitle.replace('[HD]', '').replace('’', '\'').replace('Game of Thrones –','').replace('Flash 2014','Flash')
+    year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
+    if year:
+        scrapedtitle = scrapedtitle.replace('(' + year + ')', '')
+
+
+    return scrapedtitle.strip()
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def lista_serie(item):
+    support.log(item.channel + " lista_serie")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    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:
+        infoLabels = {}
+        year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
+        if year:
+            infoLabels['year'] = year
+        scrapedtitle = cleantitle(scrapedtitle)
+
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="episodios",
+                 title=scrapedtitle,
+                 fulltitle=scrapedtitle,
+                 url=scrapedurl,
+                 thumbnail=scrapedimg,
+                 show=scrapedtitle,
+                 infoLabels=infoLabels,
+                 contentType='tvshow',
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    # Pagine
+    support.nextPage(itemlist,item,data,'<li><a href="([^"]+)">Pagina successiva')
+
+    return itemlist
+
+# ================================================================================================================
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def episodios(item):
+    support.log(item.channel + " episodios")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    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="[^"]+">)[^>]+>[^>]+>([^<]+)<'
+        matches = re.compile(patron, re.DOTALL).findall(blocco)
+        for scrapedextra, scrapedurl, scrapedimg, scrapedtitle in matches:
+            number = scrapertools.decodeHtmlentities(scrapedtitle.replace("Episodio", "")).strip()
+            itemlist.append(
+                Item(channel=item.channel,
+                     action="findvideos",
+                     title=value + "x" + number.zfill(2),
+                     fulltitle=scrapedtitle,
+                     contentType="episode",
+                     url=scrapedurl,
+                     thumbnail=scrapedimg,
+                     extra=scrapedextra,
+                     folder=True))
+
+    if config.get_videolibrary_support() and len(itemlist) != 0:
+        itemlist.append(
+            Item(channel=item.channel,
+                 title=support.typo(config.get_localized_string(30161) + ' bold color kod'),
+                 thumbnail=support.thumb(),
+                 url=item.url,
+                 action="add_serie_to_library",
+                 extra="episodios",
+                 contentSerieName=item.fulltitle,
+                 show=item.show))
+
+    return itemlist
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def findvideos(item):
+    support.log(item.channel + " findvideos")
+
+    itemlist = support.server(item, data=item.url)
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    autoplay.start(itemlist, item)
+
+    return itemlist
+
+# ================================================================================================================
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def findepisodevideo(item):
+    support.log(item.channel + " findepisodevideo")
+
+    # Download Pagina
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    # 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 = support.server(item, data=matches[0][0])
+    itemlist = filtertools.get_links(itemlist, item, list_language)
+
+    autoplay.start(itemlist, item)
+
+    return itemlist
+
+
+# ================================================================================================================
+
+
+# ----------------------------------------------------------------------------------------------------------------
+def latestep(item):
+    support.log(item.channel + " latestep")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url, headers=headers).data
+
+    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:
+        infoLabels = {}
+        year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
+        if year:
+            infoLabels['year'] = year
+        scrapedtitle = cleantitle(scrapedtitle)
+
+        infoLabels['tvshowtitle'] = scrapedtitle
+
+        episodio = re.compile(r'(\d+)x(\d+)', re.DOTALL).findall(scrapedinfo)
+        title = "%s %s" % (scrapedtitle, scrapedinfo)
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="findepisodevideo",
+                 title=title,
+                 fulltitle=scrapedtitle,
+                 url=scrapedurl,
+                 extra=episodio,
+                 thumbnail=scrapedimg,
+                 show=scrapedtitle,
+                 contentTitle=scrapedtitle,
+                 contentSerieName=title,
+                 infoLabels=infoLabels,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def newest(categoria):
+    logger.info('serietvu' + " newest" + categoria)
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == "series":
+            item.url = host + "/ultimi-episodi"
+            item.action = "latestep"
+            itemlist = latestep(item)
+
+            if itemlist[-1].action == "latestep":
+                itemlist.pop()
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+    return itemlist
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def search(item, texto):
+    logger.info(item.channel + " search")
+    item.url = host + "/?s=" + texto
+    try:
+        return lista_serie(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("%s" % line)
+        return []
+
+
+# ================================================================================================================
+
+# ----------------------------------------------------------------------------------------------------------------
+def categorie(item):
+    logger.info(item.channel +" categorie")
+    itemlist = []
+
+    data = httptools.downloadpage(item.url, headers=headers).data
+    blocco = scrapertools.find_single_match(data, r'<h2>Sfoglia</h2>\s*<ul>(.*?)</ul>\s*</section>')
+    patron = r'<li><a href="([^"]+)">([^<]+)</a></li>'
+    matches = re.compile(patron, re.DOTALL).findall(blocco)
+
+    for scrapedurl, scrapedtitle in matches:
+        if scrapedtitle == 'Home Page' or scrapedtitle == 'Calendario Aggiornamenti':
+            continue
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="lista_serie",
+                 title=scrapedtitle,
+                 contentType="tv",
+                 url="%s%s" % (host, scrapedurl),
+                 thumbnail=item.thumbnail,
+                 folder=True))
+
+    return itemlist
+
+# ================================================================================================================
diff --git a/servers/gounlimited.json b/servers/gounlimited.json
index 7b66129f..e45a2872 100644
--- a/servers/gounlimited.json
+++ b/servers/gounlimited.json
@@ -4,7 +4,7 @@
     "ignore_urls": [],
     "patterns": [
       {
-        "pattern": "https://gounlimited.to/embed-(.*?).html",
+        "pattern": "https://gounlimited.to/(?:embed-|)([a-z0-9]+)(?:.html|)",
         "url": "https://gounlimited.to/embed-\\1.html"
       }
     ]

From 09f00d6c4a9e3c447ee4849428e5c10955e5f71a Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Fri, 3 May 2019 19:51:06 +0200
Subject: [PATCH 15/23] Cineblog01 (#15)

* tvshow regex fix, better way to list episodes

* tvshow regex fix, better way to list episodes
---
 channels/cineblog01.py | 54 +++++++++++++++++++++++++++++++++++-------
 1 file changed, 46 insertions(+), 8 deletions(-)

diff --git a/channels/cineblog01.py b/channels/cineblog01.py
index ec7f3614..0f7ffa92 100644
--- a/channels/cineblog01.py
+++ b/channels/cineblog01.py
@@ -16,6 +16,7 @@ from platformcode import logger, config
 host = ""
 headers = ""
 
+
 def findhost():
     global host, headers
     permUrl = httptools.downloadpage('https://www.cb01.uno/', follow_redirects=False).headers
@@ -30,8 +31,10 @@ list_quality = ['HD', 'default']
 __comprueba_enlaces__ = config.get_setting('comprueba_enlaces', 'cineblog01')
 __comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', 'cineblog01')
 
-#esclusione degli articoli 'di servizio'
-blacklist = ['BENVENUTI', 'Richieste Serie TV', 'CB01.UNO &#x25b6; TROVA L&#8217;INDIRIZZO UFFICIALE ', 'Aggiornamento Quotidiano Serie TV', 'OSCAR 2019 ▶ CB01.UNO: Vota il tuo film preferito! 🎬', 'Openload: la situazione. Benvenuto Verystream']
+# esclusione degli articoli 'di servizio'
+blacklist = ['BENVENUTI', 'Richieste Serie TV', 'CB01.UNO &#x25b6; TROVA L&#8217;INDIRIZZO UFFICIALE ',
+             'Aggiornamento Quotidiano Serie TV', 'OSCAR 2019 ▶ CB01.UNO: Vota il tuo film preferito! 🎬',
+             'Openload: la situazione. Benvenuto Verystream']
 
 
 def mainlist(item):
@@ -152,7 +155,7 @@ def peliculas(item):
         listGroups = ['thumb', 'url', 'title', 'quality', 'year', 'genre', 'duration', 'plot']
         action = 'findvideos'
     else:
-        patron = r'div class="card-image">.*?<img src="([^ ]+)" alt.*?<a href="([^ >]+)">([^<[(]+)<\/a>.*?<strong><span style="[^"]+">([^<>0-9(]+)\(([0-9]{4}).*?<\/(p|div)>([^<>]+)'
+        patron = r'div class="card-image">.*?<img src="([^ ]+)" alt.*?<a href="([^ >]+)">([^<[(]+)<\/a>.*?<strong><span style="[^"]+">([^<>0-9(]+)\(([0-9]{4}).*?</(?:p|div)>(.*?)</div'
         listGroups = ['thumb', 'url', 'title', 'genre', 'year', 'plot']
         action = 'episodios'
 
@@ -164,9 +167,43 @@ def peliculas(item):
 
 def episodios(item):
     item.contentType = 'episode'
-    return support.scrape(item, patron_block=[r'<article class="sequex-post-content">(.*?)<\/article>',
-                                              r'<div class="sp-head[a-z ]*?" title="Espandi">[^<>]*?</div>(.*?)<div class="spdiv">\[riduci\]</div>'],
-                          patron='<p>([0-9]+(?:×|&#215;)[0-9]+)(.*?)(?:<\/p>|<br)', listGroups=['title', 'url'])
+    itemlist = []
+
+    data = httptools.downloadpage(item.url).data
+    matches = scrapertoolsV2.find_multiple_matches(data,
+                                                   r'(<div class="sp-head[a-z ]*?" title="Espandi">[^<>]*?</div>.*?)<div class="spdiv">\[riduci\]</div>')
+
+    for match in matches:
+        support.log(match)
+        blocks = scrapertoolsV2.find_multiple_matches(match, '(?:<p>)(.*?)(?:</p>|<br)')
+        season = scrapertoolsV2.find_single_match(match, r'title="Espandi">.*?STAGIONE\s+\d+([^<>]+)').strip()
+
+        for block in blocks:
+            episode = scrapertoolsV2.find_single_match(block, r'([0-9]+(?:&#215;|×)[0-9]+)').strip()
+            seasons_n = scrapertoolsV2.find_single_match(block, r'<strong>STAGIONE\s+\d+([^<>]+)').strip()
+
+            if seasons_n:
+                season = seasons_n
+
+            if not episode: continue
+
+            season = re.sub(r'&#8211;|–', "-", season)
+            itemlist.append(
+                Item(channel=item.channel,
+                     action="findvideos",
+                     contentType=item.contentType,
+                     title="[B]" + episode + "[/B] " + season,
+                     fulltitle=episode + " " + season,
+                     show=episode + " " + season,
+                     url=block,
+                     extra=item.extra,
+                     thumbnail=item.thumbnail,
+                     infoLabels=item.infoLabels
+                     ))
+
+    support.videolibrary(itemlist, item)
+
+    return itemlist
 
 
 def findvideos(item):
@@ -177,7 +214,7 @@ def findvideos(item):
 
     def load_links(itemlist, re_txt, color, desc_txt, quality=""):
         streaming = scrapertoolsV2.find_single_match(data, re_txt).replace('"', '')
-        support.log('STREAMING=',streaming)
+        support.log('STREAMING=', streaming)
         patron = '<td><a.*?href=(.*?) (?:target|rel)[^>]+>([^<]+)<'
         matches = re.compile(patron, re.DOTALL).findall(streaming)
         for scrapedurl, scrapedtitle in matches:
@@ -253,7 +290,7 @@ def findvid_serie(item):
     def load_vid_series(html, item, itemlist, blktxt):
         logger.info('HTML' + html)
         patron = '<a href="([^"]+)"[^=]+="_blank"[^>]+>(.*?)</a>'
-        # Estrae i contenuti 
+        # Estrae i contenuti
         matches = re.compile(patron, re.DOTALL).finditer(html)
         for match in matches:
             scrapedurl = match.group(1)
@@ -310,6 +347,7 @@ def findvid_serie(item):
 
     return itemlist
 
+
 def play(item):
     support.log()
     itemlist = []

From 9ac9cce63c43a7292bcebd6aef5244dff36a3b24 Mon Sep 17 00:00:00 2001
From: 4l3x87 <alex.pettiti@gmail.com>
Date: Sat, 4 May 2019 01:17:32 +0200
Subject: [PATCH 16/23] Nuovo canale Oggi in TV inserito nel menu selezione
 canali

---
 channels/filmontv.json | 12 ++++++
 channels/filmontv.py   | 89 ++++++++++++++++++++++++++++++++++++++++++
 channelselector.py     |  5 +++
 3 files changed, 106 insertions(+)
 create mode 100644 channels/filmontv.json
 create mode 100644 channels/filmontv.py

diff --git a/channels/filmontv.json b/channels/filmontv.json
new file mode 100644
index 00000000..70a0ad29
--- /dev/null
+++ b/channels/filmontv.json
@@ -0,0 +1,12 @@
+{
+    "id": "filmontv",
+    "name": "Film in tv",
+    "language": ["ita"],
+    "active": false,
+    "adult": false,
+    "thumbnail": null,
+    "banner": null,
+    "categories": [],
+    "settings": [],
+    "channel": false
+}
\ No newline at end of file
diff --git a/channels/filmontv.py b/channels/filmontv.py
new file mode 100644
index 00000000..46ade803
--- /dev/null
+++ b/channels/filmontv.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale film in tv
+# Ringraziamo Icarus crew
+# ------------------------------------------------------------
+
+import re
+import urllib
+
+from channels import support
+from core import httptools, scrapertools, tmdb
+from core.item import Item
+from platformcode import logger
+
+host = "https://www.comingsoon.it"
+
+TIMEOUT_TOTAL = 60
+
+
+def mainlist(item):
+    logger.info(" mainlist")
+    itemlist = [Item(channel=item.channel,
+                     title=support.typo("IN ONDA ADESSO bold color kod"),
+                     action="tvoggi",
+                     url="%s/filmtv/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Mattina",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/mattina/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Pomeriggio",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/pomeriggio/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Sera",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/sera/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Notte",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/notte/" % host,
+                     thumbnail="")]
+
+    return itemlist
+
+
+def tvoggi(item):
+    logger.info("filmontv tvoggi")
+    itemlist = []
+
+    # Carica la pagina 
+    data = httptools.downloadpage(item.url).data
+
+    # Estrae i contenuti 
+    patron = r'<div class="col-xs-5 box-immagine">[^<]+<img src="([^"]+)[^<]+<[^<]+<[^<]+<[^<]+<[^<]+<.*?titolo">(.*?)<[^<]+<[^<]+<[^<]+<[^>]+><br />(.*?)<[^<]+</div>[^<]+<[^<]+<[^<]+<[^>]+>[^<]+<[^<]+<[^<]+<[^>]+><[^<]+<[^>]+>:\s*([^<]+)[^<]+<[^<]+[^<]+<[^<]+[^<]+<[^<]+[^<]+[^>]+>:\s*([^<]+)'
+    # patron = r'<div class="col-xs-5 box-immagine">[^<]+<img src="([^"]+)[^<]+<[^<]+<[^<]+<[^<]+<[^<]+<.*?titolo">(.*?)<[^<]+<[^<]+<[^<]+<[^>]+><br />(.*?)<[^<]+</div>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedthumbnail, scrapedtitle, scrapedtv, scrapedgender, scrapedyear in matches:
+    # for scrapedthumbnail, scrapedtitle, scrapedtv in matches:
+        scrapedurl = ""
+        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
+        infoLabels = {}
+        infoLabels["year"] = scrapedyear
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="do_search",
+                 extra=urllib.quote_plus(scrapedtitle) + '{}' + 'movie',
+                 title=scrapedtitle + "[COLOR yellow]   " + scrapedtv + "[/COLOR]",
+                 fulltitle=scrapedtitle,
+                 url=scrapedurl,
+                 thumbnail=scrapedthumbnail,
+                 contentTitle=scrapedtitle,
+                 contentType='movie',
+                 infoLabels=infoLabels,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+
+def do_search(item):
+    from channels import search
+    return search.do_search(item)
\ No newline at end of file
diff --git a/channelselector.py b/channelselector.py
index 65c454e0..3b942e8e 100644
--- a/channelselector.py
+++ b/channelselector.py
@@ -91,6 +91,11 @@ def getchanneltypes(view="thumb_"):
                              channel_type=channel_type, viewmode="thumbnails",
                              thumbnail=get_thumb("channels_%s.png" % channel_type, view)))
 
+    itemlist.append(Item(title='Oggi in TV', channel="filmontv", action="mainlist", view=view,
+                         category=title, channel_type="all", thumbnail=get_thumb("on_the_air.png", view),
+                         viewmode="thumbnails"))
+
+
     itemlist.append(Item(title=config.get_localized_string(70685), channel="community", action="mainlist", view=view,
                          category=title, channel_type="all", thumbnail=get_thumb("channels_community.png", view),
                          viewmode="thumbnails"))

From 98a557a6dc4914b4dcbdfc7de52d40c1b012d3d8 Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Fri, 19 Apr 2019 21:13:04 +0200
Subject: [PATCH 17/23] Add parent item title, to add to videolibray item.
 Italiaserie fix

---
 channels/support.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/channels/support.py b/channels/support.py
index cbbbdf30..2f541792 100644
--- a/channels/support.py
+++ b/channels/support.py
@@ -454,7 +454,8 @@ def videolibrary(itemlist, item, typography=''):
                  url=item.url,
                  action=action,
                  extra=extra,
-                 contentTitle=item.fulltitle))
+                 contentTitle=item.fulltitle,
+                 parentTitle=item.title))
 
 
 def nextPage(itemlist, item, data, patron, function_level=1):

From 3869b68b1465249111abbecbd42880ef7b00cd9c Mon Sep 17 00:00:00 2001
From: thepasto <thepasto@gmail.com>
Date: Sat, 20 Apr 2019 11:42:10 +0200
Subject: [PATCH 18/23] List of all episodes to make add to library work as
 well Updated scrapertools regex to match italian series and episodes number

---
 channels/support.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/channels/support.py b/channels/support.py
index 2f541792..cbbbdf30 100644
--- a/channels/support.py
+++ b/channels/support.py
@@ -454,8 +454,7 @@ def videolibrary(itemlist, item, typography=''):
                  url=item.url,
                  action=action,
                  extra=extra,
-                 contentTitle=item.fulltitle,
-                 parentTitle=item.title))
+                 contentTitle=item.fulltitle))
 
 
 def nextPage(itemlist, item, data, patron, function_level=1):

From faab749a787b9aa06c538688a517f49584fbe959 Mon Sep 17 00:00:00 2001
From: 4l3x87 <50104109+4l3x87@users.noreply.github.com>
Date: Sat, 4 May 2019 11:17:44 +0200
Subject: [PATCH 19/23] Aggiunto canale Oggi in TV (#18)

* Nuovo canale Oggi in TV inserito nel menu selezione canali
---
 channels/filmontv.json | 12 ++++++
 channels/filmontv.py   | 89 ++++++++++++++++++++++++++++++++++++++++++
 channelselector.py     |  5 +++
 3 files changed, 106 insertions(+)
 create mode 100644 channels/filmontv.json
 create mode 100644 channels/filmontv.py

diff --git a/channels/filmontv.json b/channels/filmontv.json
new file mode 100644
index 00000000..70a0ad29
--- /dev/null
+++ b/channels/filmontv.json
@@ -0,0 +1,12 @@
+{
+    "id": "filmontv",
+    "name": "Film in tv",
+    "language": ["ita"],
+    "active": false,
+    "adult": false,
+    "thumbnail": null,
+    "banner": null,
+    "categories": [],
+    "settings": [],
+    "channel": false
+}
\ No newline at end of file
diff --git a/channels/filmontv.py b/channels/filmontv.py
new file mode 100644
index 00000000..46ade803
--- /dev/null
+++ b/channels/filmontv.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale film in tv
+# Ringraziamo Icarus crew
+# ------------------------------------------------------------
+
+import re
+import urllib
+
+from channels import support
+from core import httptools, scrapertools, tmdb
+from core.item import Item
+from platformcode import logger
+
+host = "https://www.comingsoon.it"
+
+TIMEOUT_TOTAL = 60
+
+
+def mainlist(item):
+    logger.info(" mainlist")
+    itemlist = [Item(channel=item.channel,
+                     title=support.typo("IN ONDA ADESSO bold color kod"),
+                     action="tvoggi",
+                     url="%s/filmtv/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Mattina",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/mattina/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Pomeriggio",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/pomeriggio/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Sera",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/sera/" % host,
+                     thumbnail=""),
+                Item(channel=item.channel,
+                     title="Notte",
+                     action="tvoggi",
+                     url="%s/filmtv/oggi/notte/" % host,
+                     thumbnail="")]
+
+    return itemlist
+
+
+def tvoggi(item):
+    logger.info("filmontv tvoggi")
+    itemlist = []
+
+    # Carica la pagina 
+    data = httptools.downloadpage(item.url).data
+
+    # Estrae i contenuti 
+    patron = r'<div class="col-xs-5 box-immagine">[^<]+<img src="([^"]+)[^<]+<[^<]+<[^<]+<[^<]+<[^<]+<.*?titolo">(.*?)<[^<]+<[^<]+<[^<]+<[^>]+><br />(.*?)<[^<]+</div>[^<]+<[^<]+<[^<]+<[^>]+>[^<]+<[^<]+<[^<]+<[^>]+><[^<]+<[^>]+>:\s*([^<]+)[^<]+<[^<]+[^<]+<[^<]+[^<]+<[^<]+[^<]+[^>]+>:\s*([^<]+)'
+    # patron = r'<div class="col-xs-5 box-immagine">[^<]+<img src="([^"]+)[^<]+<[^<]+<[^<]+<[^<]+<[^<]+<.*?titolo">(.*?)<[^<]+<[^<]+<[^<]+<[^>]+><br />(.*?)<[^<]+</div>'
+    matches = re.compile(patron, re.DOTALL).findall(data)
+
+    for scrapedthumbnail, scrapedtitle, scrapedtv, scrapedgender, scrapedyear in matches:
+    # for scrapedthumbnail, scrapedtitle, scrapedtv in matches:
+        scrapedurl = ""
+        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
+        infoLabels = {}
+        infoLabels["year"] = scrapedyear
+        itemlist.append(
+            Item(channel=item.channel,
+                 action="do_search",
+                 extra=urllib.quote_plus(scrapedtitle) + '{}' + 'movie',
+                 title=scrapedtitle + "[COLOR yellow]   " + scrapedtv + "[/COLOR]",
+                 fulltitle=scrapedtitle,
+                 url=scrapedurl,
+                 thumbnail=scrapedthumbnail,
+                 contentTitle=scrapedtitle,
+                 contentType='movie',
+                 infoLabels=infoLabels,
+                 folder=True))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    return itemlist
+
+
+def do_search(item):
+    from channels import search
+    return search.do_search(item)
\ No newline at end of file
diff --git a/channelselector.py b/channelselector.py
index 65c454e0..3b942e8e 100644
--- a/channelselector.py
+++ b/channelselector.py
@@ -91,6 +91,11 @@ def getchanneltypes(view="thumb_"):
                              channel_type=channel_type, viewmode="thumbnails",
                              thumbnail=get_thumb("channels_%s.png" % channel_type, view)))
 
+    itemlist.append(Item(title='Oggi in TV', channel="filmontv", action="mainlist", view=view,
+                         category=title, channel_type="all", thumbnail=get_thumb("on_the_air.png", view),
+                         viewmode="thumbnails"))
+
+
     itemlist.append(Item(title=config.get_localized_string(70685), channel="community", action="mainlist", view=view,
                          category=title, channel_type="all", thumbnail=get_thumb("channels_community.png", view),
                          viewmode="thumbnails"))

From e1fa7894b7f8a996b98e4777c418e97c56060066 Mon Sep 17 00:00:00 2001
From: mac12m99 <m.toma99@gmail.com>
Date: Sat, 4 May 2019 11:50:14 +0200
Subject: [PATCH 20/23] hide download serie/movie/episode if download not
 enabled

---
 platformcode/platformtools.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/platformcode/platformtools.py b/platformcode/platformtools.py
index 6befc842..3ed3ac7f 100644
--- a/platformcode/platformtools.py
+++ b/platformcode/platformtools.py
@@ -22,6 +22,9 @@ from core import channeltools
 from core import trakt_tools, scrapertoolsV2
 from core.item import Item
 from platformcode import logger
+import xbmcaddon
+addon = xbmcaddon.Addon('plugin.video.kod')
+downloadenabled = addon.getSetting('downloadenabled')
 
 
 class XBMCPlayer(xbmc.Player):
@@ -591,7 +594,7 @@ def set_context_commands(item, parent_item):
                                          (sys.argv[0], item.clone(action="add_pelicula_to_library",
                                                                   from_action=item.action).tourl())))
 
-        if item.channel != "downloads":
+        if item.channel != "downloads" and downloadenabled != "false":
             # Descargar pelicula
             if item.contentType == "movie" and item.contentTitle:
                 context_commands.append((config.get_localized_string(60354), "XBMC.RunPlugin(%s?%s)" %

From 1e87f43c61421112caa4ab17c179d70782c42bd8 Mon Sep 17 00:00:00 2001
From: mac12m99 <m.toma99@gmail.com>
Date: Sat, 4 May 2019 11:54:01 +0200
Subject: [PATCH 21/23] fix download disclaimer in ita

---
 resources/language/Italian/strings.po | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/resources/language/Italian/strings.po b/resources/language/Italian/strings.po
index 58d53ade..565ffe63 100644
--- a/resources/language/Italian/strings.po
+++ b/resources/language/Italian/strings.po
@@ -5439,11 +5439,11 @@ msgid "Disclaimer"
 msgstr "Disclaimer"
 
 msgctxt "#70691"
-msgid "Utilizzando la funzione di download dichiari di essere in possesso di una copia fisica e di utilizzare questa funzione come backup dello stesso."
+msgid "Using the download function you declare that you have a physical copy and use this function as a backup of the same."
 msgstr "Utilizzando la funzione di download dichiari di essere in possesso di una copia fisica e di utilizzare questa funzione come backup dello stesso."
 
 msgctxt "#70692"
-msgid "Il team di KOD non si assume alcuna responsabilità dell'uso che viene fatto di questa funzione proposta"
+msgid "The KOD team assumes no responsibility for the use that is made of this proposed function"
 msgstr "Il team di KOD non si assume alcuna responsabilità dell'uso che viene fatto di questa funzione proposta"
 
 msgctxt "#70693"

From 643e4b9c983ab7b4a6e31ab3867a9bf70b933fb7 Mon Sep 17 00:00:00 2001
From: mac12m99 <m.toma99@gmail.com>
Date: Sat, 4 May 2019 12:47:07 +0200
Subject: [PATCH 22/23] disable filtertools for now

---
 channels/altadefinizione01.py      |  2 +-
 channels/altadefinizione01_club.py |  2 +-
 channels/altadefinizione01_link.py |  2 +-
 channels/altadefinizioneclick.py   |  2 +-
 channels/animeleggendari.py        |  2 +-
 channels/animespace.py             |  2 +-
 channels/animeworld.py             |  2 +-
 channels/casacinema.py             |  2 +-
 channels/cineblog01.py             |  2 +-
 channels/cinehindi.py              |  2 +-
 channels/cinemalibero.py           |  2 +-
 channels/community.py              |  2 +-
 channels/doramasmp4.py             |  2 +-
 channels/dramasjc.py               |  2 +-
 channels/estrenosdoramas.py        |  2 +-
 channels/eurostreaming.py          |  2 +-
 channels/fastsubita.py             |  2 +-
 channels/filmsenzalimiti.py        |  2 +-
 channels/filmsenzalimiticc.py      |  2 +-
 channels/filtertools.py            | 15 +++++++--------
 channels/ilgeniodellostreaming.py  |  2 +-
 channels/italiafilmhd.py           |  2 +-
 channels/italiaserie.py            |  2 +-
 channels/mondoserietv.py           |  2 +-
 channels/mundopelis.py             |  2 +-
 channels/piratestreaming.py        |  2 +-
 channels/playview.py               |  2 +-
 channels/seriehd.py                |  2 +-
 channels/serietvsubita.py          |  2 +-
 channels/serietvu.py               |  4 ++--
 channels/tantifilm.py              |  2 +-
 31 files changed, 38 insertions(+), 39 deletions(-)

diff --git a/channels/altadefinizione01.py b/channels/altadefinizione01.py
index dfce8065..9f92b624 100644
--- a/channels/altadefinizione01.py
+++ b/channels/altadefinizione01.py
@@ -153,7 +153,7 @@ def findvideos(item):
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/altadefinizione01_club.py b/channels/altadefinizione01_club.py
index 7969deb5..d851bfc1 100644
--- a/channels/altadefinizione01_club.py
+++ b/channels/altadefinizione01_club.py
@@ -312,7 +312,7 @@ def findvideos_film(item):
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/altadefinizione01_link.py b/channels/altadefinizione01_link.py
index f422bcf7..3f832c5e 100644
--- a/channels/altadefinizione01_link.py
+++ b/channels/altadefinizione01_link.py
@@ -257,7 +257,7 @@ def findvideos_film(item):
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/altadefinizioneclick.py b/channels/altadefinizioneclick.py
index 66373661..d6b570a6 100644
--- a/channels/altadefinizioneclick.py
+++ b/channels/altadefinizioneclick.py
@@ -101,7 +101,7 @@ def findvideos(item):
     if __comprueba_enlaces__:
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
     support.videolibrary(itemlist, item ,'color kod bold')
diff --git a/channels/animeleggendari.py b/channels/animeleggendari.py
index 11fdfe01..0cd8d2ff 100644
--- a/channels/animeleggendari.py
+++ b/channels/animeleggendari.py
@@ -179,7 +179,7 @@ def findvideos(item):
     if __comprueba_enlaces__:
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
     autoplay.start(itemlist, item)
     
     return itemlist
diff --git a/channels/animespace.py b/channels/animespace.py
index 783ddf88..a77405b7 100644
--- a/channels/animespace.py
+++ b/channels/animespace.py
@@ -247,7 +247,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/animeworld.py b/channels/animeworld.py
index 473fb4dc..f79980a1 100644
--- a/channels/animeworld.py
+++ b/channels/animeworld.py
@@ -404,7 +404,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/casacinema.py b/channels/casacinema.py
index 2c299acf..46b06a34 100644
--- a/channels/casacinema.py
+++ b/channels/casacinema.py
@@ -355,7 +355,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/cineblog01.py b/channels/cineblog01.py
index 0f7ffa92..c721a0d2 100644
--- a/channels/cineblog01.py
+++ b/channels/cineblog01.py
@@ -275,7 +275,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/cinehindi.py b/channels/cinehindi.py
index 20f3ac0d..57505b18 100644
--- a/channels/cinehindi.py
+++ b/channels/cinehindi.py
@@ -144,7 +144,7 @@ def findvideos(item):
             itemlist.append(itemlist1[i])
     tmdb.set_infoLabels(itemlist, True)
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/cinemalibero.py b/channels/cinemalibero.py
index 8a429939..8b18fd60 100644
--- a/channels/cinemalibero.py
+++ b/channels/cinemalibero.py
@@ -226,7 +226,7 @@ def findvideos(item): # Questa def. deve sempre essere nominata findvideos
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Necessario per  FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Necessario per  AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/community.py b/channels/community.py
index 5dee10fd..53123d10 100644
--- a/channels/community.py
+++ b/channels/community.py
@@ -189,7 +189,7 @@ def findvideos(item):
     itemlist = servertools.get_servers_itemlist(itemlist, lambda i: i.title % i.server.capitalize())
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/doramasmp4.py b/channels/doramasmp4.py
index 2ab0d6c5..7c004e48 100644
--- a/channels/doramasmp4.py
+++ b/channels/doramasmp4.py
@@ -211,7 +211,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/dramasjc.py b/channels/dramasjc.py
index 7f0c19c6..340ee992 100644
--- a/channels/dramasjc.py
+++ b/channels/dramasjc.py
@@ -237,7 +237,7 @@ def findvideos(item):
         pass
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/estrenosdoramas.py b/channels/estrenosdoramas.py
index 0566a1b9..253c92ab 100644
--- a/channels/estrenosdoramas.py
+++ b/channels/estrenosdoramas.py
@@ -268,7 +268,7 @@ def findvideos(item):
     itemlist = servertools.get_servers_itemlist(itemlist)
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/eurostreaming.py b/channels/eurostreaming.py
index 0b358c1b..c9c6cd9a 100644
--- a/channels/eurostreaming.py
+++ b/channels/eurostreaming.py
@@ -397,7 +397,7 @@ def findvideos(item):
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/fastsubita.py b/channels/fastsubita.py
index dc63af08..b3d10bef 100644
--- a/channels/fastsubita.py
+++ b/channels/fastsubita.py
@@ -236,7 +236,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/filmsenzalimiti.py b/channels/filmsenzalimiti.py
index aa024154..6b51f642 100644
--- a/channels/filmsenzalimiti.py
+++ b/channels/filmsenzalimiti.py
@@ -183,7 +183,7 @@ def findvideos(item):
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Necessario per  FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Necessario per  AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/filmsenzalimiticc.py b/channels/filmsenzalimiticc.py
index befd5c30..0fd0b10f 100644
--- a/channels/filmsenzalimiticc.py
+++ b/channels/filmsenzalimiticc.py
@@ -244,7 +244,7 @@ def findvideos(item): # Questa def. deve sempre essere nominata findvideos
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
 
     # Necessario per  FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Necessario per  AutoPlay
     autoplay.start(itemlist, item)
diff --git a/channels/filtertools.py b/channels/filtertools.py
index e9a5f2a5..0195e728 100644
--- a/channels/filtertools.py
+++ b/channels/filtertools.py
@@ -120,7 +120,7 @@ def context(item, list_language=None, list_quality=None, exist=False):
         _context = []
 
     if access():
-        dict_data = {"title": "FILTRO: Configurar", "action": "config_item", "channel": "filtertools"}
+        dict_data = {"title": config.get_localized_string(60426), "action": "config_item", "channel": "filtertools"}
         if list_language:
             dict_data["list_language"] = list_language
         if list_quality:
@@ -139,10 +139,10 @@ def context(item, list_language=None, list_quality=None, exist=False):
 
         if item.action == "play":
             if not exist:
-                _context.append({"title": "FILTRO: Añadir '%s'" % item.language, "action": "save_from_context",
+                _context.append({"title": config.get_localized_string(60427) % item.language, "action": "save_from_context",
                                  "channel": "filtertools", "from_channel": item.channel})
             else:
-                _context.append({"title": "FILTRO: Borrar '%s'" % item.language, "action": "delete_from_context",
+                _context.append({"title": config.get_localized_string(60428) % item.language, "action": "delete_from_context",
                                  "channel": "filtertools", "from_channel": item.channel})
 
     return _context
@@ -150,7 +150,7 @@ def context(item, list_language=None, list_quality=None, exist=False):
 
 def show_option(itemlist, channel, list_language, list_quality):
     if access():
-        itemlist.append(Item(channel=__channel__, title="[COLOR %s]Configurar filtro para series...[/COLOR]" %
+        itemlist.append(Item(channel=__channel__, title=config.get_localized_string(60429) %
                                                         COLOR.get("parent_item", "auto"), action="load",
                              list_language=list_language,
                              list_quality=list_quality, from_channel=channel))
@@ -377,17 +377,16 @@ def mainlist(channel, list_language, list_quality):
 
         idx += 1
         name = dict_series.get(tvshow, {}).get(TAG_NAME, tvshow)
-        activo = " (desactivado)"
+        activo = config.get_localized_string(60433)
         if dict_series[tvshow][TAG_ACTIVE]:
             activo = ""
-        title = "Configurar [COLOR %s][%s][/COLOR]%s" % (tag_color, name, activo)
+        title = config.get_localized_string(60434) % (tag_color, name, activo)
 
         itemlist.append(Item(channel=__channel__, action="config_item", title=title, show=name,
                              list_language=list_language, list_quality=list_quality, from_channel=channel))
 
     if len(itemlist) == 0:
-        itemlist.append(Item(channel=channel, action="mainlist", title="No existen filtros, busca una serie y "
-                                                                       "pulsa en menú contextual 'FILTRO: Configurar'"))
+        itemlist.append(Item(channel=channel, action="mainlist", title=config.get_localized_string(60435)))
 
     return itemlist
 
diff --git a/channels/ilgeniodellostreaming.py b/channels/ilgeniodellostreaming.py
index 187bec65..3a24cc2e 100644
--- a/channels/ilgeniodellostreaming.py
+++ b/channels/ilgeniodellostreaming.py
@@ -377,7 +377,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/italiafilmhd.py b/channels/italiafilmhd.py
index ceb38433..fd15b1c3 100644
--- a/channels/italiafilmhd.py
+++ b/channels/italiafilmhd.py
@@ -303,7 +303,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/italiaserie.py b/channels/italiaserie.py
index 630d89ca..af216988 100644
--- a/channels/italiaserie.py
+++ b/channels/italiaserie.py
@@ -163,7 +163,7 @@ def findvideos(item):
     support.log()
 
     itemlist = support.server(item, data=item.url)
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
 
diff --git a/channels/mondoserietv.py b/channels/mondoserietv.py
index 6a8f156a..272e25ac 100644
--- a/channels/mondoserietv.py
+++ b/channels/mondoserietv.py
@@ -315,7 +315,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/mundopelis.py b/channels/mundopelis.py
index 3e3e8fca..ffd7b920 100644
--- a/channels/mundopelis.py
+++ b/channels/mundopelis.py
@@ -131,7 +131,7 @@ def findvideos(item):
     if __comprueba_enlaces__:
         itemlist = servertools.check_list_links(itemlist, __comprueba_enlaces_num__)
     # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
     # Requerido para AutoPlay
     autoplay.start(itemlist, item)
 
diff --git a/channels/piratestreaming.py b/channels/piratestreaming.py
index 5fddb2df..0c80d520 100644
--- a/channels/piratestreaming.py
+++ b/channels/piratestreaming.py
@@ -248,7 +248,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/playview.py b/channels/playview.py
index 9e9c02ef..fc3fd3ac 100644
--- a/channels/playview.py
+++ b/channels/playview.py
@@ -262,7 +262,7 @@ def findvideos(item):
 
         # Requerido para FilterTools
 
-        itemlist = filtertools.get_links(itemlist, item, list_language)
+        # itemlist = filtertools.get_links(itemlist, item, list_language)
 
         # Requerido para AutoPlay
 
diff --git a/channels/seriehd.py b/channels/seriehd.py
index 440c1651..58efde3d 100644
--- a/channels/seriehd.py
+++ b/channels/seriehd.py
@@ -142,7 +142,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 
diff --git a/channels/serietvsubita.py b/channels/serietvsubita.py
index ff2d3381..5edd00c0 100644
--- a/channels/serietvsubita.py
+++ b/channels/serietvsubita.py
@@ -185,7 +185,7 @@ def findvideos(item):
         data += str(scrapertools.find_multiple_matches(html, '</lable><a href="([^"]+)" target="_blank"'))
 
     itemlist = support.server(item, data=data)
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
 
diff --git a/channels/serietvu.py b/channels/serietvu.py
index 225fc6dd..2a01fb91 100644
--- a/channels/serietvu.py
+++ b/channels/serietvu.py
@@ -149,7 +149,7 @@ def findvideos(item):
     support.log(item.channel + " findvideos")
 
     itemlist = support.server(item, data=item.url)
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
 
@@ -174,7 +174,7 @@ def findepisodevideo(item):
     matches = re.compile(patron, re.DOTALL).findall(blocco)
 
     itemlist = support.server(item, data=matches[0][0])
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     autoplay.start(itemlist, item)
 
diff --git a/channels/tantifilm.py b/channels/tantifilm.py
index 7d84a445..f7443fb9 100644
--- a/channels/tantifilm.py
+++ b/channels/tantifilm.py
@@ -474,7 +474,7 @@ def findvideos(item):
 
     # Requerido para FilterTools
 
-    itemlist = filtertools.get_links(itemlist, item, list_language)
+    # itemlist = filtertools.get_links(itemlist, item, list_language)
 
     # Requerido para AutoPlay
 

From fe13788de2872c65384880c530946283412da949 Mon Sep 17 00:00:00 2001
From: mac12m99 <m.toma99@gmail.com>
Date: Sat, 4 May 2019 14:30:56 +0200
Subject: [PATCH 23/23] fix dreamsub categories

---
 channels/dreamsub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/channels/dreamsub.py b/channels/dreamsub.py
index 0a38ed23..e575ee3f 100644
--- a/channels/dreamsub.py
+++ b/channels/dreamsub.py
@@ -162,7 +162,7 @@ def categorie(item):
     matches = re.compile(patron, re.DOTALL).findall(blocco)
 
     for value in matches:
-        url = "%s/genere/%s" % (host, value)
+        url = host + '/filter?genere=' + value
         itemlist.append(
             Item(channel=item.channel,
                  action="serietv",