KoD 0.5

KoD 0.5
-riscritti molti canali per cambiamenti nella struttura stessa di kod
-altre robe carine

core/channeltools.py

@@ -79,7 +79,7 @@ def get_channel_parameters(channel_name):
                     #             break
                     #     if found:
                     #         break
-
+                    channel_parameters['settings'] = get_default_settings(channel_name)                    
                     for s in channel_parameters['settings']:
                         if 'id' in s:
                             if s['id'] == "include_in_global_search":
@@ -155,7 +155,8 @@ def get_channel_controls_settings(channel_name):
     # logger.info("channel_name=" + channel_name)
     dict_settings = {}
     # import web_pdb; web_pdb.set_trace()
-    list_controls = get_channel_json(channel_name).get('settings', list())
+    # list_controls = get_channel_json(channel_name).get('settings', list())
+    list_controls = get_default_settings(channel_name)
 
     for c in list_controls:
         if 'id' not in c or 'type' not in c or 'default' not in c:
@@ -167,6 +168,67 @@ def get_channel_controls_settings(channel_name):
 
     return list_controls, dict_settings
 
+def get_default_settings(channel_name):
+    import filetools, inspect
+    from core import support, scrapertoolsV2
+    channel = __import__('channels.%s' % channel_name, fromlist=["channels.%s" % channel_name])
+    if hasattr(channel, 'list_language'):
+        list_language = channel.list_language
+        list_language.insert(0, config.get_localized_string(70522))
+    else:
+        list_language = []
+    if 'episodios' in dir(channel):
+        episodios = getattr(__import__('channels.%s' % channel_name, fromlist=['episodios']), 'episodios')
+        anime = scrapertoolsV2.find_single_match(inspect.getsource(support.extract_wrapped(episodios)), r'(anime\s*=\s*True)')
+
+    channel_controls = get_channel_json(channel_name).get('settings', list())
+    default_path = filetools.join(config.get_runtime_path(), 'default_channel_settings' + '.json')
+    default_controls = jsontools.load(filetools.read(default_path)).get('settings', list())
+    default_controls_anime = jsontools.load(filetools.read(default_path)).get('anime', list())
+    categories = get_channel_json(channel_name).get('categories', list())
+    for control in default_controls:
+        if control['id'] not in str(channel_controls):
+            if 'include_in_newest' in control['id']:
+                label = control['id'].split('_')
+                label = label[-1]
+                if label == 'peliculas':
+                    if 'movie' not in categories:
+                        pass
+                    else:
+                        control['label'] = config.get_localized_string(70727) + ' - ' + config.get_localized_string(30122)
+                        channel_controls.append(control)
+                        logger.info(control)
+                elif label == 'series':
+                    if 'tvshow' not in categories:
+                        pass
+                    else:
+                        control['label'] = config.get_localized_string(70727) + ' - ' + config.get_localized_string(30123)
+                        channel_controls.append(control)
+                elif label == 'anime':
+                    if 'anime' not in categories:
+                        pass
+                    else:
+                        control['label'] = config.get_localized_string(70727) + ' - ' + config.get_localized_string(30124)   
+                        channel_controls.append(control) 
+                else:
+                    control['label'] = config.get_localized_string(70727) + ' - ' + label.capitalize()
+                    channel_controls.append(control)
+
+            elif control['id'] == 'filter_languages':
+                if len(list_language) > 1:
+                    control['lvalues'] = list_language
+                    channel_controls.append(control)
+                else:
+                    pass         
+            else:
+                channel_controls.append(control)
+    if anime:
+        for control in default_controls_anime:
+            if control['id'] not in str(channel_controls):
+                channel_controls.append(control)
+            else: pass
+    return channel_controls
+
 
 def get_channel_setting(name, channel, default=None):
     """

core/scrapertoolsV2.py

@@ -32,6 +32,11 @@ def find_multiple_matches(text, pattern):
     return re.findall(pattern, text, re.DOTALL)
 
 
+def find_multiple_matches_groups(text, pattern):
+    r = re.compile(pattern)
+    return [m.groupdict() for m in r.finditer(text)]
+
+
 # Convierte los codigos html "ñ" y lo reemplaza por "ñ" caracter unicode utf-8
 def decodeHtmlentities(data):
     entity_re = re.compile("&(#?)(\d{1,5}|\w{1,8})(;?)")

core/support.py

@@ -16,7 +16,6 @@ from lib import unshortenit
 from platformcode import logger, config
 from specials import autoplay
 
-
 def hdpass_get_servers(item):
     # Carica la pagina
     data = httptools.downloadpage(item.url).data.replace('\n', '')
@@ -53,7 +52,7 @@ def hdpass_get_servers(item):
                 for media_label, media_url in scrapertoolsV2.find_multiple_matches(data, patron_media):
                     itemlist.append(Item(channel=item.channel,
                                          action="play",
-                                         title=item.title+" ["+color(server, 'orange')+"]"+" - "+color(res_video, 'limegreen'),
+                                         title=item.title + typo(server, '-- [] color kod') + typo(res_video, '-- [] color kod'),
                                          fulltitle=item.fulltitle,
                                          quality=res_video,
                                          show=item.show,
@@ -93,176 +92,338 @@ def color(text, color):
     return "[COLOR " + color + "]" + text + "[/COLOR]"
 
 
-def scrape(item, patron = '', listGroups = [], headers="", blacklist="", data="", patron_block="",
-           patronNext="", action="findvideos", addVideolibrary = True, type_content_dict={}, type_action_dict={}):
+def search(channel, item, texto):
+    log(item.url + " search " + texto)
+    if 'findhost' in dir(channel):
+        channel.findhost()
+    item.url = channel.host + "/?s=" + texto
+    try:
+        return channel.peliculas(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("%s" % line)
+    return []
+
+
+def dbg():
+    import web_pdb;
+    if not web_pdb.WebPdb.active_instance:
+        import webbrowser
+        webbrowser.open('http://127.0.0.1:5555')
+    web_pdb.set_trace()
+
+
+
+def regexDbg(item, patron, headers, data=''):
+    import json, urllib2, webbrowser
+    url = 'https://regex101.com'
+
+    if not data:
+        html = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data.replace("'", '"')
+        html = re.sub('\n|\t', ' ', html)
+    else:
+        html = data
+    headers = {'content-type': 'application/json'}
+    data = {
+        'regex': patron,
+        'flags': 'gm',
+        'testString': html,
+        'delimiter': '"""',
+        'flavor': 'python'
+    }
+    r = urllib2.Request(url + '/api/regex', json.dumps(data), headers=headers)
+    r = urllib2.urlopen(r).read()
+    permaLink = json.loads(r)['permalinkFragment']
+    webbrowser.open(url + "/r/" + permaLink)
+
+
+def scrape2(item, patron = '', listGroups = [], headers="", blacklist="", data="", patronBlock="",
+           patronNext="", action="findvideos", addVideolibrary = True, typeContentDict={}, typeActionDict={}):
+    m = re.search(r'(?<!\\|\[)\((?!\?)', patron)
+    n = 0
+    while m:
+        patron = patron[:m.end()] + '?P<' + listGroups[n] + '>' + patron[m.end():]
+        m = re.search(r'(?<!\\|\[)\((?!\?)', patron)
+        n += 1
+    regexDbg(item, patron, headers)
+
+
+def scrapeLang(scraped, lang, longtitle):
+    ##    Aggiunto/modificato per gestire i siti che hanno i video
+    ##    in ita e subita delle serie tv nella stessa pagina
+    if scraped['lang']:
+        if 'sub' in scraped['lang'].lower():
+            lang = 'Sub-ITA'
+        else:
+            lang = 'ITA'
+    if lang != '':
+        longtitle += typo(lang, '_ [] color kod')
+
+    return lang, longtitle
+
+def cleantitle(title):
+    cleantitle = scrapertoolsV2.htmlclean(scrapertoolsV2.decodeHtmlentities(title).replace('"', "'").replace('×', 'x').replace('–', '-')).strip()
+    return cleantitle
+
+def scrapeBlock(item, args, block, patron, headers, action, pagination, debug, typeContentDict, typeActionDict, blacklist, search, pag, function):
+    itemlist = []
+    log("scrapeBlock qui", block, patron)
+    matches = scrapertoolsV2.find_multiple_matches_groups(block, patron)
+    log('MATCHES =', matches)
+
+    if debug:
+        regexDbg(item, patron, headers, block)
+
+    known_keys = ['url', 'title', 'title2', 'episode', 'thumb', 'quality', 'year', 'plot', 'duration', 'genere', 'rating', 'type', 'lang']
+    lang = ''  # aggiunto per gestire i siti con pagine di serietv dove si hanno i video in ita e in subita
+
+    for i, match in enumerate(matches):
+        if pagination and (pag - 1) * pagination > i: continue  # pagination
+        if pagination and i >= pag * pagination: break          # pagination
+        listGroups = match.keys()
+        match = match.values()
+
+        if len(listGroups) > len(match):  # to fix a bug
+            match = list(match)
+            match.extend([''] * (len(listGroups) - len(match)))
+
+        scraped = {}
+        for kk in known_keys:
+            val = match[listGroups.index(kk)] if kk in listGroups else ''
+            if val and (kk == "url" or kk == 'thumb') and 'http' not in val:
+                val = scrapertoolsV2.find_single_match(item.url, 'https?://[a-z0-9.-]+') + val
+            scraped[kk] = val
+        
+        
+        episode = re.sub(r'\s-\s|-|x|&#8211|&#215;', 'x', scraped['episode']) if scraped['episode'] else ''
+        title = cleantitle(scraped['title']) if scraped['title'] else ''
+        title2 = cleantitle(scraped['title2']) if scraped['title2'] else ''
+        quality = scraped['quality'] if scraped['quality'] else ''
+        Type = scraped['type'] if scraped['type'] else ''
+        plot = cleantitle(scraped["plot"]) if scraped["plot"] else ''
+       
+        # make formatted Title [longtitle]
+        s = ' - '
+        title = episode +  (s if episode and title else '') + title
+        longtitle = title + (s if title and title2 else '') + title2
+        longtitle = typo(longtitle, 'bold')
+        longtitle += (typo(Type,'_ () bold') if Type else '') +  (typo(quality, '_ [] color kod') if quality else '')
+        lang, longtitle = scrapeLang(scraped, lang, longtitle)
+
+        # if title is set, probably this is a list of episodes or video sources
+        if item.infoLabels["title"]:
+            infolabels = item.infoLabels
+        else:
+            infolabels = {}
+            if scraped['year']:
+                infolabels['year'] = scraped['year']
+            if scraped["plot"]:
+                infolabels['plot'] = plot
+            if scraped['duration']:
+                matches = scrapertoolsV2.find_multiple_matches(scraped['duration'],
+                                                               r'([0-9])\s*?(?:[hH]|:|\.|,|\\|\/|\||\s)\s*?([0-9]+)')
+                for h, m in matches:
+                    scraped['duration'] = int(h) * 60 + int(m)
+                if not matches:
+                    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"])
+
+        AC = CT = ''
+        if typeContentDict:
+            for name, variants in typeContentDict.items():
+                if str(scraped['type']).lower() in variants:
+                    CT = name
+                else: CT = item.contentType
+        if typeActionDict:
+            for name, variants in typeActionDict.items():
+                if str(scraped['type']).lower() in variants:
+                    AC = name
+                else: AC = action
+        
+        if (scraped["title"] not in blacklist) and (search.lower() in longtitle.lower()):
+            it = Item(
+                channel=item.channel,
+                action=AC if AC else action,
+                contentType='episode' if function == 'episodios' else CT if CT else item.contentType,
+                title=longtitle,
+                fulltitle=item.fulltitle if function == 'episodios' else title,
+                show=item.show if function == 'episodios' else title,
+                quality=quality,
+                url=scraped["url"],
+                infoLabels=infolabels,
+                thumbnail=item.thumbnail if function == 'episodios' else scraped["thumb"] ,
+                args=item.args,
+                contentSerieName= title if item.contentType != 'movie' and function != 'episodios' else item.fulltitle if function == 'episodios' else '',
+                contentTitle= title if item.contentType == 'movie' else '',
+                contentLanguage=lang,
+                ep=episode if episode else ''
+            )
+            
+            for lg in list(set(listGroups).difference(known_keys)):
+                it.__setattr__(lg, match[listGroups.index(lg)])
+
+            if 'itemHook' in args:
+                it = args['itemHook'](it)
+            itemlist.append(it)
+
+    return itemlist, matches
+
+
+def scrape(func):
+    # args is a dict containing the foolowing keys:
     # patron: the patron to use for scraping page, all capturing group must match with listGroups
     # listGroups: a list containing the scraping info obtained by your patron, in order
     # accepted values are: url, title, thumb, quality, year, plot, duration, genre, rating, episode, lang
 
-    # header: values to pass to request header
+    # headers: values to pass to request header
     # blacklist: titles that you want to exclude(service articles for example)
     # data: if you want to pass data manually, maybe because you need some custom replacement
-    # patron_block: patron to get parts of the page (to scrape with patron attribute),
+    # patronBlock: patron to get parts of the page (to scrape with patron attribute),
     #               if you need a "block inside another block" you can create a list, please note that all matches
     #               will be packed as string
     # patronNext: patron for scraping next page link
     # action: if you want results perform an action different from "findvideos", useful when scraping film by genres
-    # url_host: string to prepend to scrapedurl, useful when url don't contain host
+    # addVideolibrary: if "add to videolibrary" should appear
     # example usage:
     #   import support
     #   itemlist = []
     #   patron = 'blablabla'
     #   headers = [['Referer', host]]
     #   blacklist = 'Request a TV serie!'
-    #   return support.scrape(item, itemlist, patron, ['thumb', 'quality', 'url', 'title', 'title2', 'year', 'plot', 'episode', 'lang'],
+    #   return support.scrape(item, itemlist, patron, ['thumb', 'quality', 'url', 'title', 'year', 'plot', 'episode', 'lang'],
     #                           headers=headers, blacklist=blacklist)
-    # listGroups
-    #    thumb = immagine, quality = qualità, url = link singolo o gruppo, title = titolo film o serie, title2 = titolo aggiuntivo
-    #    year = anno del film o della serie, plot = descrizione film o serie, episode = numero stagione - numero episodio in caso di serie,
-    #    lang = lingua del video
     # 'type' is a check for typologies of content e.g. Film or TV Series
     # 'episode' is a key to grab episode numbers if it is separated from the title
-    # IMPORTANT 'type' is a special key, to work need type_content_dict={} and type_action_dict={}
+    # IMPORTANT 'type' is a special key, to work need typeContentDict={} and typeActionDict={}
 
-    itemlist = []
+    def wrapper(*args):
+        function = func.__name__
+        itemlist = []
 
-    if not data:
-        data = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data.replace("'", '"')
-        data = re.sub('\n|\t', ' ', data)
-        # replace all ' with " and eliminate newline, so we don't need to worry about
-        log('DATA =', data)
+        args = func(*args)
 
-        block = data
+        item = args['item']
 
-        if patron_block:
-            if type(patron_block) == str:
-                patron_block = [patron_block]
-
-            for n, regex in enumerate(patron_block):
-                blocks = scrapertoolsV2.find_multiple_matches(block, regex)
-                block = ""
-                for b in blocks:
-                    block += "\n" + str(b)
-                log('BLOCK ', n, '=', block)
-    else:
-        block = data
-    if patron and listGroups:
-        matches = scrapertoolsV2.find_multiple_matches(block, patron)
-        log('MATCHES =', matches)
-
-        known_keys = ['url', 'title', 'title2', 'episode', 'thumb', 'quality', 'year', 'plot', 'duration', 'genere', 'rating', 'type', 'lang'] #by greko aggiunto episode
-        lang = '' # aggiunto per gestire i siti con pagine di serietv dove si hanno i video in ita e in subita
-        
-        for match in matches:
-            if len(listGroups) > len(match):  # to fix a bug
-                match = list(match)
-                match.extend([''] * (len(listGroups) - len(match)))
-
-            scraped = {}
-            for kk in known_keys:
-                val = match[listGroups.index(kk)] if kk in listGroups else ''
-                if val and (kk == "url" or kk == 'thumb') and 'http' not in val:
-                    val = scrapertoolsV2.find_single_match(item.url, 'https?://[a-z0-9.-]+') + val
-                scraped[kk] = val
-
-            title = scrapertoolsV2.htmlclean(scrapertoolsV2.decodeHtmlentities(scraped["title"])).replace('’', '\'').replace('"', "'").strip() # fix by greko da " a '
-            plot = scrapertoolsV2.htmlclean(scrapertoolsV2.decodeHtmlentities(scraped["plot"]))
-
-            longtitle = typo(title, 'bold')
-            if scraped['quality']: longtitle = longtitle + typo(scraped['quality'], '_ [] color kod')
-            if scraped['episode']:
-                scraped['episode'] = re.sub(r'\s-\s|-|x|&#8211', 'x' , scraped['episode'])
-                longtitle = typo(scraped['episode'] + ' - ', 'bold') + longtitle
-            if scraped['title2']:
-                title2 = scrapertoolsV2.htmlclean(scrapertoolsV2.decodeHtmlentities(scraped["title2"])).replace('"', "'").strip()
-                longtitle = longtitle + typo(title2, 'bold _ -- _')
-
-            ##    Aggiunto/modificato per gestire i siti che hanno i video
-            ##    in ita e subita delle serie tv nella stessa pagina
-            if scraped['lang'] == '': #altrimenti nei canali dei film mi aggiunge sub-ita a tutti i film successivi
-                lang = '' # o in alternativa lang = 'ITA'
-            if scraped['lang']:              
-                if 'sub' in scraped['lang'].lower():
-                    lang = 'Sub-ITA'
-                else:
-                    lang = 'ITA'                      
-            if lang != '':
-                longtitle += typo(lang, '_ [] color kod')
-
-            if item.infoLabels["title"] or item.fulltitle:  # if title is set, probably this is a list of episodes or video sources
-                infolabels = item.infoLabels
-            else:
-                infolabels = {}
-                if scraped["year"]:
-                    infolabels['year'] = scraped["year"]
-                if scraped["plot"]:
-                    infolabels['plot'] = plot
-                if scraped["duration"]:
-                    matches = scrapertoolsV2.find_multiple_matches(scraped["duration"],r'([0-9])\s*?(?:[hH]|:|\.|,|\\|\/|\||\s)\s*?([0-9]+)')
-                    for h, m in matches:
-                        scraped["duration"] = int(h) * 60 + int(m)
-                    if not matches:
-                        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 type_content_dict:
-                for name, variants in type_content_dict.items():
-                    if scraped['type'] in variants:
-                        item.contentType = name
-            if type_action_dict:
-                for name, variants in type_action_dict.items():
-                    if scraped['type'] in variants:
-                        action = name
-
-            if inspect.stack()[1][3] == 'episodios':  item.contentType = 'episode'
-
-            if scraped["title"] not in blacklist:
-                it = Item(
-                    channel=item.channel,
-                    action=action,
-                    contentType=item.contentType,
-                    title=longtitle,
-                    fulltitle=title,
-                    show=title,
-                    language = lang if lang != '' else '',
-                    quality=scraped["quality"],
-                    url=scraped["url"],
-                    infoLabels=infolabels,
-                    thumbnail=scraped["thumb"],
-                    args=item.args
-                )
-
-                for lg in list(set(listGroups).difference(known_keys)):
-                    it.__setattr__(lg, match[listGroups.index(lg)])
-
-                itemlist.append(it)
-        checkHost(item, itemlist)
-        if (item.contentType == "tvshow" and (action != "findvideos" and action != "play")) \
-                or (item.contentType == "episode" and action != "play") \
-                or (item.contentType == "movie" and action != "play"):
-            tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+        action = args['action'] if 'action' in args else 'findvideos'
+        anime = args['anime'] if 'anime' in args else ''
+        addVideolibrary = args['addVideolibrary'] if 'addVideolibrary' in args else True
+        search = args['search'] if 'search' in args else ''
+        blacklist = args['blacklist'] if 'blacklist' in args else []
+        data = args['data'] if 'data' in args else ''
+        patron = args['patron'] if 'patron' in args else args['patronMenu'] if 'patronMenu' in args else ''
+        if 'headers' in args:
+            headers = args['headers']
+        elif 'headers' in func.__globals__:
+            headers = func.__globals__['headers']
         else:
-            for it in itemlist:
-                it.infoLabels = item.infoLabels
+            headers = ''
+        patronNext = args['patronNext'] if 'patronNext' in args else ''
+        patronBlock = args['patronBlock'] if 'patronBlock' in args else ''
+        typeActionDict = args['type_action_dict'] if 'type_action_dict' in args else {}
+        typeContentDict = args['type_content_dict'] if 'type_content_dict' in args else {}
+        debug = args['debug'] if 'debug' in args else False
+        if 'pagination' in args: pagination = args['pagination'] if args['pagination'] else 20
+        else: pagination = ''
+        list_language = func.__globals__['list_language'] if 'list_language' in func.__globals__ else {}
+
+        pag = item.page if item.page else 1  # pagination
+        matches = []
+
+        log('PATRON= ', patron)
+        if not data:
+            data = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data.replace("'", '"')
+            data = re.sub('\n|\t', ' ', data)
+            data = re.sub('>\s+<', '> <', data)
+            # replace all ' with " and eliminate newline, so we don't need to worry about
+            log('DATA =', data)
+
+        if patronBlock:
+            blocks = scrapertoolsV2.find_multiple_matches_groups(data, patronBlock) 
+            block = ""
+            for bl in blocks:
+                blockItemlist, blockMatches = scrapeBlock(item, args, bl['block'], patron, headers, action, pagination, debug,
+                                            typeContentDict, typeActionDict, blacklist, search, pag, function)
+                for it in blockItemlist:
+                    if 'lang' in bl:
+                        it.contentLanguage, it.title = scrapeLang(bl, it.contentLanguage, it.title)
+                    if 'quality' in bl and bl['quality']:
+                        it.quality = bl['quality']
+                        it.title = it.title + typo(bl['quality'], '_ [] color kod')
+                log('BLOCK ', '=', block)
+                itemlist.extend(blockItemlist)
+                matches.extend(blockMatches)
+        elif patron:
+            itemlist, matches = scrapeBlock(item, args, data, patron, headers, action, pagination, debug, typeContentDict,
+                                   typeActionDict, blacklist, search, pag, function)
+        
+        checkHost(item, itemlist)
+
+        
+
+        if 'itemlistHook' in args:
+            itemlist = args['itemlistHook'](itemlist)
 
         if patronNext:
             nextPage(itemlist, item, data, patronNext, 2)
 
-        if addVideolibrary and (item.infoLabels["title"] or item.fulltitle):
-            item.fulltitle = item.infoLabels["title"]
-            videolibrary(itemlist, item)
+        # next page for pagination
+        if pagination and len(matches) >= pag * pagination:
+            itemlist.append(
+                Item(channel=item.channel,
+                     action = item.action,
+                     contentType=item.contentType,
+                     title=typo(config.get_localized_string(30992), 'color kod bold'),
+                     url=item.url,
+                     args=item.args,
+                     page=pag + 1,
+                     thumbnail=thumb()))
 
-    return itemlist
+        if action != 'play' and function != 'episodios' and 'patronMenu' not in args:
+            tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+        if anime:
+            from specials import autorenumber
+            if function == 'episodios' or item.action == 'episodios': autorenumber.renumber(itemlist, item, 'bold')
+            else: autorenumber.renumber(itemlist)
+
+        if addVideolibrary and (item.infoLabels["title"] or item.fulltitle):
+            # item.fulltitle = item.infoLabels["title"]
+            videolibrary(itemlist, item, function=function)
+        if config.get_setting('downloadenabled') and (function == 'episodios' or function == 'finvideos'):
+            download(itemlist, item, function=function)
+
+        if 'patronMenu' in args:
+            itemlist = thumb(itemlist, genre=True)
+
+        if 'fullItemlistHook' in args:
+            itemlist = args['fullItemlistHook'](itemlist)
+        
+        filterLang = False
+        for item in itemlist:
+            if item.contentLanguage:
+                filterLang = True
+                break
+            
+        if list_language and filterLang:
+            log('Lista Lingue = ', list_language)
+            from specials import filtertools
+            return filtertools.get_links(itemlist, item, list_language)
+        else:
+            return itemlist
+
+    return wrapper
 
 
 def checkHost(item, itemlist):
     # nel caso non ci siano risultati puo essere che l'utente abbia cambiato manualmente l'host, pertanto lo riporta
-    # al valore di default (fixa anche il problema del cambio di host da parte nostra)
+    # al valore di default (fixa anche il problema  del cambio di host da parte nostra)
     if len(itemlist) == 0:
         # trovo il valore di default
         defHost = None
@@ -303,61 +464,51 @@ def dooplay_get_links(item, host):
     return ret
 
 
+@scrape
 def dooplay_get_episodes(item):
-    itemlist = []
     item.contentType = "episode"
-    data = httptools.downloadpage(item.url).data.replace("'", '"')
-    patron = '<li class="mark-[0-9]">.*?<img.*?data-lazy-src="([^"]+).*?([0-9] - [0-9]).*?<a href="([^"]+)">([^<>]+).*?([0-9]{4})'
-
-    for scrapedthumb, scrapedep, scrapedurl, scrapedtitle, scrapedyear in scrapertoolsV2.find_multiple_matches(data, patron):
-        scrapedep = scrapedep.replace(' - ', 'x')
-        infoLabels = {}
-        infoLabels['year'] = scrapedyear
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="episode",
-                 title=scrapedep + " " + scrapedtitle,
-                 fulltitle=scrapedtitle,
-                 show=item.fulltitle,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumb,
-                 infoLabels=infoLabels
-                 )
-        )
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    videolibrary(itemlist, item)
-    return itemlist
+    patron = '<li class="mark-[0-9]+">.*?<img.*?(?:data-lazy-)?src="(?P<thumb>[^"]+).*?(?P<episode>[0-9]+ - [0-9]+).*?<a href="(?P<url>[^"]+)">(?P<title>[^<>]+).*?(?P<year>[0-9]{4})'
+    # debug = True
+    return locals()
 
 
+@scrape
 def dooplay_films(item, blacklist=""):
-    if item.contentType == 'movie':
-        action = 'findvideos'
-        patron = '<article id="post-[0-9]+" class="item movies">.*?<img src="(?!data)([^"]+)".*?<span class="quality">([^<>]+).*?<a href="([^"]+)">([^<>]+)</a></h3>.*?(?:<span>([0-9]{4})</span>|</article>).*?(?:<span>([0-9]+) min</span>|</article>).*?(?:<div class="texto">([^<>]+)|</article>).*?(?:genres">(.*?)</div>|</article>)'
+    if item.args == 'searchPage':
+        return dooplay_search_vars(item, blacklist)
     else:
-        action = 'episodios'
-        patron = '<article id="post-[0-9]+" class="item tvshows">.*?<img src="(?!data)([^"]+)".*?(?:<span class="quality">([^<>]+))?.*?<a href="([^"]+)">([^<>]+)</a></h3>.*?(?:<span>([0-9]{4})</span>|</article>).*?(?:<span>([0-9]+) min</span>|</article>).*?(?:<div class="texto">([^<>]+)|</article>).*?(?:genres">(.*?)</div>|</article>)'
-    # patronNext = '<a class="arrow_pag" href="([^"]+)"><i id="nextpagination"'
-    patronNext = '<div class="pagination">.*?class="current".*?<a href="([^"]+)".*?<div class="resppages">'
-    itemlist = scrape(item, patron, ['thumb', 'quality', 'url', 'title', 'year', 'duration', 'plot', 'genre'], blacklist=blacklist, patronNext=patronNext, action=action, addVideolibrary=False)
-    if itemlist and 'Successivo' in itemlist[-1].title:
-        itemlist[-1].action = 'peliculas'
+        if item.contentType == 'movie':
+            action = 'findvideos'
+            patron = '<article id="post-[0-9]+" class="item movies">.*?<img src="(?!data)(?P<thumb>[^"]+)".*?<span class="quality">(?P<quality>[^<>]+).*?<a href="(?P<url>[^"]+)">(?P<title>[^<>]+)</a></h3>.*?(?:<span>[^<>]*(?P<year>[0-9]{4})</span>|</article>).*?(?:<span>(?P<duration>[0-9]+) min</span>|</article>).*?(?:<div class="texto">(?P<plot>[^<>]+)|</article>).*?(?:genres">(?P<genre>.*?)</div>|</article>)'
+        else:
+            action = 'episodios'
+            patron = '<article id="post-[0-9]+" class="item tvshows">.*?<img src="(?!data)(?P<thumb>[^"]+)".*?(?:<span class="quality">(?P<quality>[^<>]+))?.*?<a href="(?P<url>[^"]+)">(?P<title>[^<>]+)</a></h3>.*?(?:<span>(?P<year>[0-9]{4})</span>|</article>).*?(?:<div class="texto">(?P<plot>[^<>]+)|</article>).*?(?:genres">(?P<genre>.*?)</div>|</article>)'
+        patronNext = '<div class="pagination">.*?class="current".*?<a href="([^"]+)".*?<div class="resppages">'
+        addVideolibrary = False
 
-    return itemlist
+        return locals()
 
-    
+
+@scrape
 def dooplay_search(item, blacklist=""):
+    return dooplay_search_vars(item, blacklist)
+
+def dooplay_search_vars(item, blacklist):
     if item.contentType == 'movie':
         type = 'movies'
         action = 'findvideos'
     else:
         type = 'tvshows'
         action = 'episodios'
-    patron = '<div class="result-item">.*?<img src="([^"]+)".*?<span class="' + type + '">([^<>]+).*?<a href="([^"]+)">([^<>]+)</a>.*?<span class="year">([0-9]{4}).*?<div class="contenido"><p>([^<>]+)'
+    patron = '<div class="result-item">.*?<img src="(?P<thumb>[^"]+)".*?<span class="' + type + '">(?P<quality>[^<>]+).*?<a href="(?P<url>[^"]+)">(?P<title>[^<>]+)</a>.*?<span class="year">(?P<year>[0-9]{4}).*?<div class="contenido"><p>(?P<plot>[^<>]+)'
     patronNext = '<a class="arrow_pag" href="([^"]+)"><i id="nextpagination"'
-    return scrape(item, patron, ['thumb', 'quality', 'url', 'title', 'year', 'plot'], blacklist=blacklist, patronNext=patronNext, action=action)
-
+    def fullItemlistHook(itemlist):
+        # se è una next page
+        if itemlist[-1].title == typo(config.get_localized_string(30992), 'color kod bold'):
+            itemlist[-1].action = 'peliculas'
+            itemlist[-1].args = 'searchPage'
+        return itemlist
+    return locals()
 
 def swzz_get_url(item):
     headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:59.0) Gecko/20100101 Firefox/59.0'}
@@ -398,13 +549,9 @@ def swzz_get_url(item):
     return data
 
 
-def menu(itemlist, title='', action='', url='', contentType='movie', args=[]):
+def menuItem(itemlist, filename, title='', action='', url='', contentType='movie', args=[]):
     # Function to simplify menu creation
 
-    frame = inspect.stack()[1]
-    filename = frame[0].f_code.co_filename
-    filename = os.path.basename(filename).replace('.py','')
-
     # Call typo function
     title = typo(title)
 
@@ -420,14 +567,98 @@ def menu(itemlist, title='', action='', url='', contentType='movie', args=[]):
         args = args,
         contentType = contentType
     ))
-
+   
     # Apply auto Thumbnails at the menus
     from channelselector import thumb
     thumb(itemlist)
-
     return itemlist
 
 
+def menu(func):
+    def wrapper(*args):
+        log()
+        args = func(*args)
+
+        item = args['item']
+        host = func.__globals__['host']
+        list_servers = func.__globals__['list_servers']
+        list_quality = func.__globals__['list_quality']
+        filename = func.__module__.split('.')[1]
+
+        # listUrls = ['film', 'filmSub', 'tvshow', 'tvshowSub', 'anime', 'animeSub', 'search', 'top', 'topSub']
+        listUrls = ['top', 'film', 'tvshow', 'anime', 'search']
+        listUrls_extra = []
+        dictUrl = {}
+
+
+        # Main options
+        itemlist = []
+
+        for name in listUrls:
+            dictUrl[name] = args[name] if name in args else None
+            log(dictUrl[name])
+            if name == 'film': title = 'Film'
+            if name == 'tvshow': title = 'Serie TV'
+            if name == 'anime': title = 'Anime'
+
+            if name == 'search' and dictUrl[name] is not None:
+                menuItem(itemlist, filename, 'Cerca… bold', 'search', host + dictUrl['search'])
+
+            # Make TOP MENU
+            elif name == 'top' and dictUrl[name] is not None:
+                for sub, var in dictUrl['top']:
+                    menuItem(itemlist, filename,
+                             title = sub + ' italic bold',
+                             url = host + var[0] if len(var) > 0 else '',
+                             action = var[1] if len(var) > 1 else 'peliculas',
+                             args=var[2] if len(var) > 2 else '',
+                             contentType= var[3] if len(var) > 3 else 'movie',)
+
+            # Make MAIN MENU
+            elif dictUrl[name] is not None:
+                if len(dictUrl[name]) == 0: url = ''
+                else: url = dictUrl[name][0] if type(dictUrl[name][0]) is not tuple and len(dictUrl[name][0]) > 0 else ''
+                menuItem(itemlist, filename,
+                         title + ' bullet bold', 'peliculas',
+                         host + url,
+                         contentType='movie' if name == 'film' else 'tvshow')
+                if len(dictUrl[name]) > 0:
+                    if type(dictUrl[name][0]) is not tuple and type(dictUrl[name]) is not str: dictUrl[name].pop(0)
+                if dictUrl[name] is not None and type(dictUrl[name]) is not str:
+                    for sub, var in dictUrl[name]:
+                        menuItem(itemlist, filename,
+                             title = sub + ' submenu' + typo(title,'_ {}'),
+                             url = host + var[0] if len(var) > 0 else '',
+                             action = var[1] if len(var) > 1 else 'peliculas',
+                             args=var[2] if len(var) > 2 else '',
+                             contentType= var[3] if len(var) > 3 else 'movie' if name == 'film' else 'tvshow',)
+                # add search menu for category
+                if 'search' not in args: menuItem(itemlist, filename, 'Cerca ' + title + '… submenu bold', 'search', host + url, contentType='movie' if name == 'film' else 'tvshow')
+                
+        # Make EXTRA MENU (on bottom)
+        for name, var in args.items():
+            if name not in listUrls and name != 'item':
+               listUrls_extra.append(name)
+        for name in listUrls_extra:
+            dictUrl[name] = args[name] if name in args else None
+            for sub, var in dictUrl[name]:
+                menuItem(itemlist, filename,
+                             title = sub + ' ',
+                             url = host + var[0] if len(var) > 0 else '',
+                             action = var[1] if len(var) > 1 else 'peliculas',
+                             args=var[2] if len(var) > 2 else '',
+                             contentType= var[3] if len(var) > 3 else 'movie',)
+
+
+        autoplay.init(item.channel, list_servers, list_quality)
+        autoplay.show_option(item.channel, itemlist)
+        channel_config(item, itemlist) 
+        
+        return itemlist
+
+    return wrapper
+
+
 def typo(string, typography=''):
 
     kod_color = '0xFF65B3DA' #'0xFF0081C2'
@@ -463,7 +694,7 @@ def typo(string, typography=''):
         if '{}' in string:
             string = '{' + re.sub(r'\s\{\}','',string) + '}'
         if 'submenu' in string:
-            string = ' > ' + re.sub(r'\ssubmenu','',string)
+            string = u"\u2022\u2022 ".encode('utf-8') + re.sub(r'\ssubmenu','',string)
         if 'color' in string:
             color = scrapertoolsV2.find_single_match(string,'color ([a-z]+)')
             if color == 'kod' or '': color = kod_color
@@ -476,20 +707,25 @@ def typo(string, typography=''):
             string = ' ' + re.sub(r'\s_','',string)
         if '--' in string:
             string = ' - ' + re.sub(r'\s--','',string)
+        if 'bullet' in string:
+            string = '[B]' + u"\u2022".encode('utf-8') + '[/B] ' + re.sub(r'\sbullet','',string)
 
     return string
 
 
-def match(item, patron='', patron_block='', headers='', url=''):
+def match(item, patron='', patronBlock='', headers='', url='', post=''):
     matches = []
-    url = url if url else item.url
-    data = httptools.downloadpage(url, headers=headers, ignore_response_code=True).data.replace("'", '"')
+    if type(item) == str:
+        data = item
+    else:
+        url = url if url else item.url
+        data = httptools.downloadpage(url, headers=headers, ignore_response_code=True, post=post).data.replace("'", '"')
     data = re.sub(r'\n|\t', ' ', data)
-    data = re.sub(r'>\s\s*<', '><', data)
+    data = re.sub(r'>\s\s*<', '><', data)    
     log('DATA= ', data)
 
-    if patron_block:
-        block = scrapertoolsV2.find_single_match(data, patron_block)
+    if patronBlock:
+        block = scrapertoolsV2.find_single_match(data, patronBlock)
         log('BLOCK= ',block)
     else:
         block = data
@@ -498,13 +734,64 @@ def match(item, patron='', patron_block='', headers='', url=''):
         matches = scrapertoolsV2.find_multiple_matches(block, patron)
         log('MATCHES= ',matches)
 
-    return matches, data
+    return matches, block
 
 
-def videolibrary(itemlist, item, typography='', function_level=1):
+def download(itemlist, item, typography='', function_level=1, function=''):
+    if not typography: typography = 'color kod bold'
+
+    if item.contentType == 'movie':       
+        fromaction = 'findvideos'
+        title = typo(config.get_localized_string(60354), typography)
+    elif item.contentType == 'episode':       
+        fromaction = 'findvideos'
+        title = typo(config.get_localized_string(60356), typography) + ' - ' + item.title
+    else:        
+        fromaction = 'episodios'
+        title = typo(config.get_localized_string(60355), typography)
+
+    function = function if function else inspect.stack()[function_level][3]
+    
+    contentSerieName=item.contentSerieName if item.contentSerieName else ''
+    contentTitle=item.contentTitle if item.contentTitle else ''
+    if item.contentChannel != 'videolibrary':
+        itemlist.append(
+            Item(channel='downloads',
+                fromchannel=item.channel,
+                title=title,
+                fulltitle=item.fulltitle,
+                show=item.fulltitle,
+                contentType=item.contentType,
+                contentSerieName=contentSerieName,
+                url=item.url,
+                action='save_download',
+                fromaction=fromaction,
+                contentTitle=contentTitle
+            ))
+        if fromaction == 'episodios':
+            itemlist.append(
+                Item(channel='downloads',
+                    fromchannel=item.channel,
+                    title=typo(config.get_localized_string(60357),typography),
+                    fulltitle=item.fulltitle,
+                    show=item.fulltitle,
+                    contentType=item.contentType,
+                    contentSerieName=contentSerieName,
+                    url=item.url,
+                    action='save_download',
+                    fromaction=fromaction,
+                    contentTitle=contentTitle,
+                    download='season'
+                ))
+
+    return itemlist
+
+
+def videolibrary(itemlist, item, typography='', function_level=1, function=''):
     # Simply add this function to add video library support
     # Function_level is useful if the function is called by another function.
     # If the call is direct, leave it blank
+    log()
 
     if item.contentType == 'movie':
         action = 'add_pelicula_to_library'
@@ -515,22 +802,29 @@ def videolibrary(itemlist, item, typography='', function_level=1):
         extra = 'episodios'
         contentType = 'tvshow'
 
+    function = function if function else inspect.stack()[function_level][3]
+
     if not typography: typography = 'color kod bold'
 
-    title = typo(config.get_localized_string(30161) + ' ' + typography)
-    log('STACK= ',inspect.stack()[function_level][3])
-    if (inspect.stack()[function_level][3] == 'findvideos' and contentType == 'movie') \
-        or (inspect.stack()[function_level][3] == 'episodios' and contentType != 'movie'):
+    title = typo(config.get_localized_string(30161), typography)
+    contentSerieName=item.contentSerieName if item.contentSerieName else ''
+    contentTitle=item.contentTitle if item.contentTitle else ''
+
+    if (function == 'findvideos' and contentType == 'movie') \
+        or (function == 'episodios' and contentType != 'movie'):
         if config.get_videolibrary_support() and len(itemlist) > 0:
             itemlist.append(
                 Item(channel=item.channel,
-                     title=title,
-                     contentType=contentType,
-                     contentSerieName=item.fulltitle if contentType == 'tvshow' else '',
-                     url=item.url,
-                     action=action,
-                     extra=extra,
-                     contentTitle=item.fulltitle))
+                        title=title,
+                        fulltitle=item.fulltitle,
+                        show=item.fulltitle,
+                        contentType=contentType,
+                        contentSerieName=contentSerieName,
+                        url=item.url,
+                        action=action,
+                        extra=extra,
+                        contentTitle=contentTitle
+                        ))
 
     return itemlist
 
@@ -544,10 +838,11 @@ def nextPage(itemlist, item, data='', patron='', function_level=1, next_page='',
         if resub: next_page = re.sub(resub[0], resub[1], next_page)
         if 'http' not in next_page:
             next_page = scrapertoolsV2.find_single_match(item.url, 'https?://[a-z0-9.-]+') + next_page
+        next_page = re.sub('&amp;', '&',next_page)
         log('NEXT= ', next_page)
         itemlist.append(
             Item(channel=item.channel,
-                 action=inspect.stack()[function_level][3],
+                 action = item.action,
                  contentType=item.contentType,
                  title=typo(config.get_localized_string(30992), 'color kod bold'),
                  url=next_page,
@@ -557,7 +852,7 @@ def nextPage(itemlist, item, data='', patron='', function_level=1, next_page='',
     return itemlist
 
 def pagination(itemlist, item, page, perpage, function_level=1):
-    if len(itemlist) >= perpage: # page * perpage
+    if len(itemlist) >= page * perpage:
         itemlist.append(
             Item(channel=item.channel,
                  action=inspect.stack()[function_level][3],
@@ -579,8 +874,8 @@ def server(item, data='', itemlist=[], headers='', AutoPlay=True, CheckLinks=Tru
     itemlist += itemList
     
     for videoitem in itemlist:
-        item.title = typo(item.contentTitle,'bold') if item.contentType == 'movie' else item.title
-        videoitem.title = "".join([item.title, typo(videoitem.title, '_ color kod []'), typo(videoitem.quality, '_ color kod []') if videoitem.quality else ""])
+        item.title = item.contentTitle if config.get_localized_string(30161) in item.title else item.title
+        videoitem.title = "".join([item.title, ' ', typo(videoitem.title, 'color kod []'), typo(videoitem.quality, 'color kod []') if videoitem.quality else ""])
         videoitem.fulltitle = item.fulltitle
         videoitem.show = item.show
         videoitem.thumbnail = item.thumbnail
@@ -620,6 +915,7 @@ def controls(itemlist, item, AutoPlay=True, CheckLinks=True):
         autoplay.start(itemlist, item)
 
     if item.contentChannel != 'videolibrary': videolibrary(itemlist, item, function_level=3)
+    if get_setting('downloadenabled'): download(itemlist, item, function_level=3)
     return itemlist
 
 
@@ -652,3 +948,8 @@ def channel_config(item, itemlist):
              thumbnail=get_thumb('setting_0.png'))
     )
 
+
+def extract_wrapped(decorated):
+    from types import FunctionType
+    closure = (c.cell_contents for c in decorated.__closure__)
+    return next((c for c in closure if isinstance(c, FunctionType)), None)

core/videolibrarytools.py

@@ -203,6 +203,7 @@ def save_movie(item):
             item_nfo.library_urls[item.channel] = item.url
 
             if filetools.write(nfo_path, head_nfo + item_nfo.tojson()):
+                #logger.info("FOLDER_MOVIES : %s" % FOLDER_MOVIES)
                 # actualizamos la videoteca de Kodi con la pelicula
                 if config.is_xbmc():
                     from platformcode import xbmc_videolibrary
@@ -339,7 +340,7 @@ def save_tvshow(item, episodelist):
     '''msg = "Insertados: %d | Sobreescritos: %d | Fallidos: %d | Tiempo: %2.2f segundos" % \
           (insertados, sobreescritos, fallidos, time.time() - start_time)
     logger.debug(msg)'''
-
+    
     return insertados, sobreescritos, fallidos, path
 
 
@@ -397,7 +398,8 @@ def save_episodes(path, episodelist, serie, silent=False, overwrite=True):
     channel_alt = generictools.verify_channel(serie.channel)            #Preparamos para añadir las urls de emergencia
     emergency_urls_stat = config.get_setting("emergency_urls", channel_alt)         #El canal quiere urls de emergencia?
     emergency_urls_succ = False
-    channel = __import__('channels.%s' % channel_alt, fromlist=["channels.%s" % channel_alt])
+    try: channel = __import__('specials.%s' % channel_alt, fromlist=["specials.%s" % channel_alt])
+    except: channel = __import__('channels.%s' % channel_alt, fromlist=["channels.%s" % channel_alt])
     if serie.torrent_caching_fail:                              #Si el proceso de conversión ha fallado, no se cachean
         emergency_urls_stat = 0
         del serie.torrent_caching_fail
@@ -676,7 +678,8 @@ def add_tvshow(item, channel=None):
 
         if not channel:
             try:
-                channel = __import__('channels.%s' % item.channel, fromlist=["channels.%s" % item.channel])
+                #channel = __import__('channels.%s' % item.channel, fromlist=["channels.%s" % item.channel])
+                channel = __import__('specials.%s' % channel_alt, fromlist=["specials.%s" % channel_alt])
             except ImportError:
                 exec "import channels." + item.channel + " as channel"
 
@@ -740,7 +743,8 @@ def emergency_urls(item, channel=None, path=None):
     try:
         if channel == None:                             #Si el llamador no ha aportado la estructura de channel, se crea
             channel = generictools.verify_channel(item.channel)             #Se verifica si es un clon, que devuelva "newpct1"
-            channel = __import__('channels.%s' % channel, fromlist=["channels.%s" % channel])
+            #channel = __import__('channels.%s' % channel, fromlist=["channels.%s" % channel])
+            channel = __import__('specials.%s' % channel_alt, fromlist=["specials.%s" % channel_alt])
         if hasattr(channel, 'findvideos'):                                  #Si el canal tiene "findvideos"...
             item.videolibray_emergency_urls = True                          #... se marca como "lookup"
             channel_save = item.channel                 #... guarda el canal original por si hay fail-over en Newpct1