Aggiornamento domini

Reviewed-on: #1

.gitea/workflows/updateDomains.yaml

@@ -0,0 +1,38 @@
+name: Update channel domains
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 17 * * *'
+  push:
+    branches:
+      - master
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    steps:
+    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+    - uses: actions/checkout@v2
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.7'
+        architecture: 'x64'
+
+    - name: Install dependencies
+      run: pip install requests
+
+    - name: Update domains
+      run: python tools/updateDomains.py
+    - name: Configure git
+      run: |
+        git config user.name "Gitea CI Bot"
+        git config user.email "ci-bot@gitea.local"
+    - name: Commit changes
+      run: |
+        git add .
+        git commit -m "Aggiornamento domini" || echo "No changes to commit"
+    - name: push
+      run: |
+        git push https://stevazi:${{ secrets.API_TOKEN_GITHUB }}@git.stevazi.mywire.org/stevazi/addon.git master

.github/workflows/tests.yml

@@ -1,28 +1,25 @@
 name: Test Suite
 on:
   workflow_dispatch:
-  schedule:
-    - cron: '00 15 * * *'
 
 jobs:
   tests:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v4.3.0
         with:
-          python-version: 3.8
+          python-version: 3.9
 
       - name: Run tests
         run: |
-          export KODI_INTERACTIVE=0
           ./tests/run.sh
 
       - name: Commit & Push changes
-        uses: dmnemec/copy_file_to_another_repo_action@v1.0.4
+        uses: dmnemec/copy_file_to_another_repo_action@main
         env:
           API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }}
         with:

.gitignore

@@ -7,3 +7,7 @@ custom_code.json
 last_commit.txt
 __pycache__/
 .vscode/settings.json
+bin/
+lib/abi
+tests/home/
+reports/

addon.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<addon id="plugin.video.kod" name="Kodi on Demand BETA" version="1.7" provider-name="KoD Team">
+<addon id="plugin.video.kod" name="Kodi on Demand" version="1.7.7" provider-name="KoD Team">
   <requires>
     <!-- <import addon="script.module.libtorrent" optional="true"/> -->
-    <import addon="metadata.themoviedb.org"/>
-    <import addon="metadata.tvshows.themoviedb.org"/>
+    <import addon="metadata.themoviedb.org" optional="true"/>
+    <import addon="metadata.tvshows.themoviedb.org" optional="true"/>
     <!-- <import addon="metadata.tvdb.com"/> -->
-    <import addon="script.module.web-pdb" />
+ 
   </requires>
   <extension point="xbmc.python.pluginsource" library="default.py">
     <provides>video</provides>
@@ -28,9 +28,7 @@
       <screenshot>resources/media/screenshot-2.png</screenshot>
       <screenshot>resources/media/screenshot-3.png</screenshot>
     </assets>
-      <news>- Aggiunto menu globale "opzioni di KoD"
-- Aggiunto canale tapmovie e server annessi
-- Notifica quando il tipo di vista viene salvata (con indicazione del tipo di contenuto)
+      <news>- fix di routine ai canali/server
 </news>
     <description lang="it">Naviga velocemente sul web e guarda i contenuti presenti</description>
     <disclaimer>[COLOR red]The owners and submitters to this addon do not host or distribute any of the content displayed by these addons nor do they have any affiliation with the content providers.[/COLOR]

channels.json

@@ -1,54 +1,46 @@
 {
     "direct": {
-        "altadefinizione01": "https://www.altadefinizione01.plus",
-        "altadefinizione01_link": "https://altadefinizione01.travel",
-        "animealtadefinizione": "https://www.animealtadefinizione.it",
+        "altadefinizione01": "https://altadefinizione01.spa",
+        "animealtadefinizione": "http://ww38.animealtadefinizione.it",
         "animeforce": "https://www.animeforce.it",
-        "animeleggendari": "https://animezeus.com",
-        "animesaturn": "https://www.animesaturn.it",
-        "animeunity": "https://www.animeunity.it",
-        "animeuniverse": "https://www.animeuniverse.it",
-        "animeworld": "https://www.animeworld.tv",
-        "aniplay": "https://aniplay.it",
-        "casacinema": "https://www.casacinema.page",
-        "cb01anime": "https://www.cineblog01.red",
-        "cineblog01": "https://cb01.uno",
-        "cinemalibero": "https://cinemalibero.bar",
+        "animesaturn": "https://www.animesaturn.cx",
+        "animeunity": "https://www.animeunity.tv",
+        "animeworld": "https://www.animeworld.ac",
+        "aniplay": "https://aniplay.co",
+        "bt4g": "https://bt4gprx.com",
+        "casacinema": "https://casacinema.im",
+        "cb01anime": "https://cb01new.one",
+        "cinemalibero": "https://cinemalibero.cafe",
         "cinetecadibologna": "http://cinestore.cinetecadibologna.it",
+        "dinostreaming": "https://dinostreaming.it",
         "discoveryplus": "https://www.discoveryplus.com",
-        "dreamsub": "https://dreamsub.stream",
-        "dsda": "https://www.dsda.press",
-        "eurostreaming": "https://eurostreaming.bar",
-        "filmigratis": "https://filmigratis.org",
-        "guardaseriecam": "https://guardaserie.cam",
-        "guardaserieclick": "https://www.guardaserie.builders",
-        "guardaserieicu": "https://guardaserie.cfd",
+        "dreamsub": "https://www.animeworld.ac",
+        "eurostreaming": "https://eurostreaming.lifestyle",
+        "eurostreaming_actor": "https://eurostreaming.my",
+        "filmstreaming": "https://film-streaming-ita.cam",
+        "guardaseriecam": "https://guardaserie.kitchen",
         "hd4me": "https://hd4me.net",
         "ilcorsaronero": "https://ilcorsaronero.link",
-        "ilgeniodellostreaming": "https://ilgeniodellostreaming.wtf",
-        "ilgeniodellostreaming_cam": "https://ilgeniodellostreaming.city",
-        "italiaserie": "https://italiaserie.date",
-        "mediasetplay": "https://www.mediasetplay.mediaset.it",
-        "mondoserietv": "https://mondoserietv.club",
-        "paramount": "https://www.paramountnetwork.it",
-        "piratestreaming": "https://www.piratestreaming.design",
-        "polpotv": "https://roma.polpo.tv",
+        "ilgeniodellostreaming_cam": "https://ilgeniodellostreaming.foo",
+        "italiafilm": "https://italia-film.lifestyle",
+        "lordchannel": "https://expireddomains.com/domain/lordchannel.com",
+        "mediasetplay": "https://mediasetinfinity.mediaset.it",
+        "mondoserietv": "http://ww25.mondoserietv.club/?subid1=20230304-0434-261c-9cb0-a0044930e0a9",
+        "paramount": "https://www.mtv.it",
+        "piratestreaming": "https://piratestreaming.design",
+        "plutotv": "https://pluto.tv",
         "raiplay": "https://www.raiplay.it",
-        "seriehd": "https://altadefinizionecommunity.casa",
-        "serietvonline": "https://serietvonline.art",
-        "serietvsubita": "http://serietvsubita.xyz",
-        "serietvu": "https://www.serietvu.live",
-        "streamingcommunity": "https://streamingcommunity.vip",
-        "streamtime": "https://t.me/s/StreamTime",
-        "tantifilm": "https://www.tantifilm.stream",
-        "tapmovie": "https://it.tapmovie.net",
-        "toonitalia": "https://toonitalia.co",
-        "vvvvid": "https://www.vvvvid.it"
+        "serietvu": "http://ww1.serietvu.live/?sub1=47fb879a-5325-11ee-94a7-cc35006f53d1",
+        "streamingcommunity": "https://streamingcommunity.ooo",
+        "streamingita": "https://streamingita.click",
+        "tantifilm": "https://tantifilm.name",
+        "toonitalia": "https://toonitalia.xyz"
     },
     "findhost": {
-        "altadefinizioneclick": "https://altadefinizione-nuovo.click",
-        "altadefinizionecommunity": "https://altaregistrazione.com",
+        "altadefinizione": "https://altadefinizione.nuovo.live",
+        "altadefinizionecommunity": "https://altaregistrazione.net",
         "animealtadefinizione": "https://www.animealtadefinizione.it",
+        "cineblog01": "https://cb01.uno",
         "filmpertutti": "https://filmpertuttiii.nuovo.live"
     }
 }

channels/0example.py.txt

@@ -9,7 +9,7 @@
 # fix:
 # 1. aggiunto pagination e sistemate alcune voci
 # 2. modificato problemi in eccezioni
-# 3. aggiunta la def select
+# 3. aggiunta la def check
 # 4. modifica alla legenda e altre aggiunte
 
 # Questo vuole solo essere uno scheletro per velocizzare la scrittura di un canale.
@@ -197,7 +197,7 @@ def genres(item):
 # per quei casi dove il sito non differenzia film e/o serie e/o anime
 # e la ricerca porta i titoli mischiati senza poterli distinguere tra loro
 # andranno modificate anche le def peliculas e episodios ove occorre
-def select(item):
+def check(item):
     support.info('select --->', item)
     #support.dbg()
     data = httptools.downloadpage(item.url, headers=headers).data

channels/1337x.json

@@ -0,0 +1,20 @@
+{
+    "id": "1337x",
+    "name": "1337x",
+    "language": ["ita", "sub-ita", "eng"],
+    "active": true,
+    "thumbnail": "1337x.png",
+    "banner": "1337x.png",
+    "categories": ["movie", "tvshow", "torrent"],
+    "not_active": ["include_in_newest"],
+    "settings": [
+        {
+            "id": "itaSearch",
+            "type": "bool",
+            "label": "Cerca contenuti in italiano",
+            "default": false,
+            "enabled": true,
+            "visible": true
+        }
+    ]
+}

channels/1337x.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 1337x
+# ------------------------------------------------------------
+
+import inspect
+from core import support
+from platformcode import logger, config
+
+# host = support.config.get_channel_url()
+host = 'https://www.1337x.to'
+
+@support.menu
+def mainlist(item):
+
+    menu = [('Film ITA {bullet bold}',['/movie-lib-sort/all/it/popularity/desc/all/1/', 'peliculas', '', 'movie']),
+            ('Film {submenu}',['/movie-library/1/', 'peliculas', 'filter', 'movie']),
+            ('Serie TV {bullet bold}',['/series-library/', 'az', '', 'tvshow'])]
+
+    search = ''
+
+    return locals()
+
+
+def moviefilter(item):
+    if logger.testMode:
+        return host +'/movie-lib-sort/all/all/score/desc/all/1/'
+    from platformcode import platformtools
+
+    item.args = ''
+    controls = []
+    data = support.match(item).data
+
+    patronBlock = r'<select name="{}"[^>]+>(.+?)</select>'
+    patron = r'value="([^"]+)">([^<]+)'
+
+    genres = support.match(data, patronBlock=patronBlock.format('genre'), patron=patron).matches
+    years = support.match(data, patronBlock=patronBlock.format('year'), patron=patron).matches
+    langs = support.match(data, patronBlock=patronBlock.format('lang'), patron=patron).matches
+    sorts = support.match(data, patronBlock=patronBlock.format('sortby'), patron=patron).matches
+    orders = support.match(data, patronBlock=patronBlock.format('sort'), patron=patron).matches
+
+    item.genreValues = [x[0] for x in genres]
+    item.yearValues = [x[0] for x in years]
+    item.langValues = [x[0] for x in langs]
+    item.sortValues = [x[0] for x in sorts]
+    item.orderValues = [x[0] for x in orders]
+
+    genres = [g[1] for g in genres]
+    years = [g[1] for g in years]
+    langs = [g[1] for g in langs]
+    sorts = [g[1] for g in sorts]
+    orders = [g[1] for g in orders]
+
+    controls.append({'id': 'lang', 'label': 'Lingua', 'type': 'list', 'enabled':True, 'visible':True, 'lvalues':langs, 'default': 0})
+    controls.append({'id': 'genre', 'label': 'Genere', 'type': 'list', 'enabled':True, 'visible':True, 'lvalues':genres, 'default': 0})
+    controls.append({'id': 'year', 'label': 'Anno', 'type': 'list', 'enabled':True, 'visible':True, 'lvalues':years, 'default': 0})
+    controls.append({'id': 'sort', 'label': 'Anno', 'type': 'list', 'enabled':True, 'visible':True, 'lvalues':sorts, 'default': 0})
+    controls.append({'id': 'order', 'label': 'Anno', 'type': 'list', 'enabled':True, 'visible':True, 'lvalues':orders, 'default': 0})
+    return platformtools.show_channel_settings(list_controls=controls, item=item, caption='Filtro', callback='filtered')
+
+
+
+def filtered(item, values):
+    genre = item.genreValues[values['genre']]
+    lang = item.langValues[values['lang']]
+    sortby = item.sortValues[values['sort']]
+    order = item.orderValues[values['order']]
+    year = item.yearValues[values['year']]
+
+    return '{}/movie-lib-sort/{}/{}/{}/{}/{}/1/'.format(host, genre, lang, sortby, order, year)
+
+
+def az(item):
+    import string
+    itemlist = [item.clone(title='1-9', url=item.url +'num/1/', action='peliculas', thumbnail=support.thumb('az'))]
+    for letter in list(string.ascii_lowercase):
+        itemlist.append(item.clone(title=letter.upper(), url=item.url + letter +'/1/', action='peliculas', thumbnail=support.thumb('az')))
+    return itemlist
+
+
+def search(item, text):
+    support.info('search', text)
+    item.args = 'search'
+    if config.get_setting('itaSearch', channel=item.channel, default=False):
+        text += ' ita'
+    text = text.replace(' ', '+')
+    item.url = '{}/search/{}/1/'.format(host, text)
+    try:
+        return peliculas(item)
+    # Cattura la eccezione così non interrompe la ricerca globle se il canale si rompe!
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.logger.error("search except: ", line)
+        return []
+
+@support.scrape
+def peliculas(item):
+    if item.args == 'filter':
+        item.url = moviefilter(item)
+    if not item.url:
+        data = ' '
+    else:
+        data = support.match(item).data
+    # debug = True
+    if item.args == 'search':
+        sceneTitle = 'undefined'
+        patron = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)<(?:[^>]+>){3,7}(?P<seed>[^<]+)<(?:[^>]+>){6}(?P<size>[^<]+)<span'
+        patronNext = r'"([^"]+)">&gt;&gt;'
+    elif item.contentType == 'movie':
+        patron = r'<img[^>]+data-original="(?P<thumb>[^"]+)(?:[^>]+>){15}(?P<title>[^<]+).*?<p>(?P<plot>[^<]+).*?<a href="(?P<url>[^"]+)'
+        patronNext = r'"([^"]+)">&gt;&gt;'
+    else:
+        action = 'seasons'
+        patron = r'<img src="(?P<thumb>[^"]+)(?:[^>]+>){4}\s*<a href="(?P<url>[^"]+)[^>]+>(?P<title>[^<]+)'
+
+    if (item.args == 'search' or item.contentType != 'movie') and not support.stackCheck(['get_channel_results']):
+        patronNext = None
+        def itemlistHook(itemlist):
+            lastUrl = support.match(data, patron=r'href="([^"]+)">Last').match
+            if lastUrl:
+                currentPage = support.match(item.url, string=True, patron=r'/(\d+)/').match
+                nextPage = int(currentPage) + 1
+                support.nextPage(itemlist, item, next_page=item.url.replace('/{}'.format(currentPage), '/{}'.format(nextPage)), function_or_level='peliculas')
+            return itemlist
+
+    return locals()
+
+
+@support.scrape
+def seasons(item):
+    item.contentType = 'season'
+    action = 'episodios'
+    patron = r'<li>\s*<a href="(?P<url>[^"]+)[^>]+>\s*<img alt="[^"]*"\ssrc="(?P<thumb>[^"]+)(?:([^>]+)>){2}\s*(?P<title>\w+ (?P<season>\d+))'
+    return locals()
+
+@support.scrape
+def episodios(item):
+    patron = r'<img src="(?P<thumb>[^"]+)(?:[^>]+>){13}\s*(?P<season>\d+)x(?P<episode>\d+)\s*<span class="seperator">(?:[^>]+>){2}\s*<a href="(?P<url>[^"]+)">(?P<title>[^<]+)'
+    def itemlistHook(itemlist):
+        itemlist.reverse()
+        return itemlist
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    item.disableAutoplay = True
+    if item.args == 'search':
+        itemlist.append(item.clone(server='torrent', action='play'))
+    else:
+        from lib.guessit import guessit
+
+        items = support.match(item.url, patron=r'<a href="([^"]+)">([^<]+)<(?:[^>]+>){3}([^<]+)<(?:[^>]+>){6}([^<]+)<span').matches
+
+        for url, title, seed, size in items:
+            parsedTitle = guessit(title)
+
+            title = support.scrapertools.unescape(parsedTitle.get('title', ''))
+
+            lang = ''
+            if parsedTitle.get('language'):
+                langs = parsedTitle.get('language')
+                if isinstance(langs, list):
+                    lang = 'MULTI'
+                else:
+                    lang = vars(langs).get('alpha3').upper()
+                if not (lang.startswith('MUL') or lang.startswith('ITA')):
+                    subs = parsedTitle.get('subtitle_language')
+                    if isinstance(subs, list):
+                        lang = 'Multi-Sub'
+                    else:
+                        lang = vars(subs).get('alpha3').upper()
+            if lang:
+                title = '{} [{}]'.format(title, lang)
+
+            sizematch = support.match(size, patron='(\d+(?:\.\d+)?)\s* (\w+)').match
+            sizenumber = float(sizematch[0])
+            if sizematch[1].lower() == 'gb':
+                sizenumber = sizenumber * 1024
+
+            itemlist.append(item.clone(title = '{} [{} SEEDS] [{}]'.format(title, seed, size), seed=int(seed), size=sizenumber, url=host + url, server='torrent', action='play'))
+        itemlist.sort(key=lambda it: (it.seed, it.size), reverse=True)
+
+    Videolibrary = True if 'movie' in item.args else False
+    return support.server(item, itemlist=itemlist, Videolibrary=Videolibrary, Sorted=False)
+
+
+def play(item):
+    from core import servertools
+    data = support.match(item.url, patron=r'href="(magnet[^"]+)').match
+    return servertools.find_video_items(item, data=data)

channels/accuradio.py

@@ -35,8 +35,9 @@ def mainlist(item):
 
 @support.scrape
 def peliculas(item):
+    # debug=True
     action = 'playradio'
-    patron = r'data-id="(?P<id>[^"]+)"\s*data-oldid="(?P<oldid>[^"]+)".*?data-name="(?P<title>[^"]+)(?:[^>]+>){5}<img class="[^"]+"\s*src="(?P<thumb>[^"]+)(?:[^>]+>){6}\s*(?P<plot>[^<]+)'
+    patron = r'data-id="(?P<id>[^"]+)"\s*data-oldid="(?P<oldid>[^"]+)".*?data-name="(?P<title>[^"]+)(?:[^>]+>){2}<img src="(?P<thumb>[^"]+)(?:[^>]+>){16}\s*(?P<plot>[^<]+)'
     return locals()
 
 

channels/altadefinizione.json

@@ -0,0 +1,11 @@
+{
+    "id": "altadefinizione",
+    "name": "Altadefinizione",
+    "language": ["ita", "sub-ita"],
+    "active": true,
+    "thumbnail": "altadefinizione.png",
+    "banner": "altadefinizione.png",
+    "categories": ["movie", "tvshow", "vos"],
+    "settings": [],
+    "not_active": ["include_in_newest"]
+}

channels/altadefinizione.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per altadefinizione
+# ------------------------------------------------------------
+
+
+from core import httptools, support, tmdb, scrapertools
+from platformcode import config, logger
+import re
+
+def findhost(url):
+    host = support.match(url, patron=r'<h2[^>]+><a href="([^"]+)').match.rstrip('/')
+    permUrl = httptools.downloadpage(host,  follow_redirects=False, only_headers=True).headers
+
+    if 'location' in permUrl.keys(): # handle redirection
+        return permUrl['location']
+    return host
+
+host = config.get_channel_url(findhost)
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    menu = [('Film',['/category/film/', 'peliculas', '', 'movie']),
+            ('Film al cinema {submenu}',['/category/ora-al-cinema/', 'peliculas', '', 'movie']),
+            ('Generi',['', 'genres', '', 'undefined']),
+            ('Saghe',['', 'genres', 'saghe', 'undefined']),
+            ('Serie TV',['/category/serie-tv/', 'peliculas', '', 'tvshow']),
+            #('Aggiornamenti Serie TV', ['/aggiornamenti-serie-tv/', 'peliculas']) da fixare
+            ]
+    search = ''
+    return locals()
+
+@support.scrape
+def genres(item):
+    action = 'peliculas'
+    blacklist = ['Scegli il Genere', 'Film', 'Serie Tv', 'Sub-Ita', 'Anime', "Non reperibile", 'Anime Sub-ITA', 'Prossimamente',]
+    wantSaga = True if item.args == 'saghe' else False
+
+    patronBlock = r'<div class=\"categories-buttons-container\"(?P<block>.*?)</div>'
+    if not wantSaga: # se non richiedo le sage carico le icone in automatico
+        patronMenu = r'<a href=\"(?P<url>https:\/\/.*?)\".*?>(?P<title>.*?)</a>'
+    else: # mantengo l'icona del padre
+        patron = r'<a href=\"(?P<url>https:\/\/.*?)\".*?>(?P<title>.*?)</a>'
+
+    def itemlistHook(itemlist):
+        itl = []
+        for item in itemlist:
+            isSaga = item.fulltitle.startswith('Saga')
+
+            if len(item.fulltitle) != 3:
+                if (isSaga and wantSaga) or (not isSaga and not wantSaga):
+                    itl.append(item)
+        return itl
+    return locals()
+
+
+def search(item, text):
+    item.url = "{}/?{}".format(host, support.urlencode({'s': text}))
+    item.args = 'search'
+
+    try:
+        return peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("search except: %s" % line)
+        return []
+
+@support.scrape
+def peliculas(item):
+    if not item.args == 'search': # pagination not works
+        if not item.nextpage:
+            item.page = 1
+        else:
+            item.page = item.nextpage
+
+        if not item.parent_url:
+            item.parent_url = item.url
+
+        item.nextpage = item.page + 1
+        nextPageUrl = "{}/page/{}".format(item.parent_url, item.nextpage)
+        resp = httptools.downloadpage(nextPageUrl, only_headers = True)
+        if (resp.code > 399): # no more elements
+            nextPageUrl = ''
+    else:
+        action = 'check'
+
+    patron= r'<article class=\"elementor-post.*?(<img .*?src=\"(?P<thumb>[^\"]+).*?)?<h1 class=\"elementor-post__title\".*?<a href=\"(?P<url>[^\"]+)\" >\s*(?P<title>[^<]+?)\s*(\((?P<lang>Sub-[a-zA-Z]+)*\))?\s*(\[(?P<quality>[A-Z]*)\])?\s*(\((?P<year>[0-9]{4})\))?\s+<'
+
+    return locals()
+
+def episodios(item):
+    item.quality = ''
+    data = item.data if item.data else httptools.downloadpage(item.url).data
+    itemlist = []
+
+    for it in support.match(data, patron=[r'div class=\"single-season.*?(?P<id>season_[0-9]+).*?>Stagione:\s(?P<season>[0-9]+).*?(\s-\s(?P<lang>[a-zA-z]+?))?<']).matches:
+        block = support.match(data, patron = r'div id=\"'+ it[0] +'\".*?</div').match
+        for ep in support.match(block, patron=[r'<li><a href=\"(?P<url>[^\"]+).*?img\" src=\"(?P<thumb>[^\"]+).*?title\">(?P<episode>[0-9]+)\.\s+(?P<title>.*?)</span>']).matches:
+            itemlist.append(item.clone(contentType = 'episode',
+                                   action='findvideos',
+                                   thumb = ep[1],
+                                   title = support.format_longtitle(support.cleantitle(ep[3]), season = it[1], episode = ep[2], lang= it[3]),
+                                   url = ep[0], data = '')
+                        )
+
+    support.check_trakt(itemlist)
+    support.videolibrary(itemlist, item)
+    if (config.get_setting('downloadenabled')):
+        support.download(itemlist, item)
+
+    return itemlist
+
+def check(item):
+    item.data = httptools.downloadpage(item.url).data
+    if 'season-details' in item.data.lower():
+        item.contentType = 'tvshow'
+        return episodios(item)
+    else:
+        return findvideos(item)
+
+
+def findvideos(item):
+    video_url = item.url
+
+    if item.contentType == 'movie':
+        video_url = support.match(item, patron=[r'<div class="video-wrapper">.*?<iframe src=\"(https://.*?)\"',
+                                                r'window.open\(\'([^\']+).*?_blank']).match
+    if (video_url == ''):
+       return []
+    itemlist = [item.clone(action="play", url=srv) for srv in support.match(video_url, patron='<div class="megaButton" meta-type="v" meta-link="([^"]+).*?(?=>)>').matches]
+    itemlist = support.server(item,itemlist=itemlist)
+
+    return itemlist

channels/altadefinizione01.py

@@ -51,13 +51,14 @@ def peliculas(item):
     action="findvideos"
 
     patron = r'<div class="cover boxcaption"> +<h2>\s*<a href="(?P<url>[^"]+)">(?P<title>[^<]+).*?src="(?P<thumb>[^"]+).*?<div class="trdublaj">(?P<quality>[^<]+).*?<span class="ml-label">(?P<year>[0-9]+).*?<span class="ml-label">(?P<duration>[^<]+).*?<p>(?P<plot>[^<]+)'
+    patronNext =  '<span>\d</span> <a href="([^"]+)">'
 
     if item.args == "search":
         patronBlock = r'</script> <div class="boxgrid caption">(?P<block>.*)<div id="right_bar">'
-        
     elif item.args == 'update':
         patronBlock = r'<div class="widget-title">Ultimi Film Aggiunti/Aggiornati</div>(?P<block>.*?)<div id="alt_menu">'
-        patron = r'style="background-image:url\((?P<thumb>[^\)]+).+?<p class="h4">(?P<title>.*?)</p>[^>]+> [^>]+> [^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+> [^>]+> [^>]+>[^>]+>(?P<year>\d{4})[^>]+>[^>]+> [^>]+>[^>]+>(?P<duration>\d+|N/A).+?>.*?(?:>Film (?P<lang>Sub ITA)</a></p> )?<p>(?P<plot>[^<]+)<.*?href="(?P<url>[^"]+)'
+        patron = r'style="background-image:url\((?P<thumb>[^\)]+).+?<p class="h4">(?P<title>.*?)</p>[^>]+> [^>]+> [^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+> [^>]+> [^>]+>[^>]+>(?P<year>\d{4})[^>]+>[^>]+> [^>]+>[^>]+>(?P<duration>\d+|N/A)?.+?>.*?(?:>Film (?P<lang>Sub ITA)</a></p> )?<p>(?P<plot>[^<]+)<.*?href="(?P<url>[^"]+)'
+        patronNext = ''  # non ha nessuna paginazione
     elif item.args == 'orderalf':
         patron = r'<td class="mlnh-thumb"><a href="(?P<url>[^"]+)".*?src="(?P<thumb>[^"]+)"' \
                  '.+?[^>]+>[^>]+ [^>]+[^>]+ [^>]+>(?P<title>[^<]+).*?[^>]+>(?P<year>\d{4})<' \
@@ -65,7 +66,6 @@ def peliculas(item):
     else:
         patronBlock = r'<div class="cover_kapsul ml-mask">(?P<block>.*)<div class="page_nav">'
 
-    patronNext =  '<span>\d</span> <a href="([^"]+)">'
     # debug = True
     return locals()
 
@@ -141,13 +141,17 @@ def newest(categoria):
 
     return itemlist
 
+
 def findvideos(item):
     support.info('findvideos', item)
     data = httptools.downloadpage(item.url).data
-    iframe = support.match(data, patron='player-container[^>]+>\s*<iframe[^>]+src="([^"]+)').match
+    iframe = support.match(data, patron='src="(http[^"]+)" frameborder=\"0\" allow=\"accelerometer; autoplay;').match
     if iframe:
         item.url = iframe
     return support.server(item)
-    else:
-        itemlist = [item.clone(action="play", url=srv[0], quality=srv[1]) for srv in support.match(item, patron='<a href="#" data-link="([^"]+).*?<span class="d">([^<]+)').matches]
-        return support.server(item, itemlist=itemlist, headers=headers)
+    
+    # TODO: verificare se si puo' reinsierire il trailer youtube
+    #itemlist = [item.clone(action="play", url=srv[0], quality=srv[1]) for srv in support.match(item, patron='<a href="#" data-link="([^"]+).*?<span class="d">([^<]+)').matches]
+    #itemlist = support.server(item, itemlist=itemlist, headers=headers)   
+        
+    #return itemlist

channels/altadefinizione01_link.json

@@ -1,10 +0,0 @@
-{
-  "id": "altadefinizione01_link",
-  "name": "Altadefinizione01 L",
-  "active": false,
-  "language": ["ita","sub-ita"],
-  "thumbnail": "altadefinizione01_L.png",
-  "banner": "altadefinizione01_L.png",
-  "categories": ["movie","vos"],
-  "settings" :[]
-}

channels/altadefinizione01_link.py

@@ -1,105 +0,0 @@
-# -*- coding: utf-8 -*-
-# -*- Channel altadefinizione01_link -*-
-
-from core import support
-from core.item import Item
-from platformcode import config, logger
-
-__channel__ = "altadefinizione01_link"
-
-# ======== def per utility INIZIO ============================
-host = config.get_channel_url()
-headers = [['Referer', host]]
-
-
-# =========== home menu ===================
-@support.menu
-def mainlist(item):
-    support.info('mainlist',item)
-
-    film = [
-        ('Al Cinema', ['/film-del-cinema', 'peliculas', '']),
-        ('Generi', ['', 'genres', 'genres']),
-        ('Anni', ['', 'genres', 'years']),
-        ('Qualità', ['/piu-visti.html', 'genres', 'quality']),
-        ('Mi sento fortunato', ['/piu-visti.html', 'genres', 'lucky']),
-        ('Popolari', ['/piu-visti.html', 'peliculas', '']),
-        ('Sub-ITA', ['/film-sub-ita/', 'peliculas', ''])
-    ]
-    return locals()
-
-# ======== def in ordine di action dal menu ===========================
-
-@support.scrape
-def peliculas(item):
-    # debug = True
-    support.info('peliculas',item)
-
-    patron = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)(?:[^>]+>){5}\s*<div class="[^"]+" style="background-image:url\((?P<thumb>[^\)]+)(?:[^>]+>){6}\s*(?P<year>\d{4})[^>]+>[^>]+>(?:\s*(?P<duration>\d+))?(?:[^>]+>){0,2}\s+(?P<quality>[a-zA-Z]+)\s+(?:[^>]+>){2}\s*(?P<lang>[^>]+)\s+[^>]+>'
-    patronNext = r'<span>\d</span> <a href="([^"]+)">'
-    # debug = True
-    return locals()
-
-# =========== def pagina categorie ======================================
-@support.scrape
-def genres(item):
-    support.info('genres',item)
-
-    action = 'peliculas'
-    if item.args == 'genres':
-        patronBlock = r'<ul class="listSubCat" id="Film">(?P<block>.*)<ul class="listSubCat" id="Anno">'
-    elif item.args == 'years':
-        patronBlock = r'<ul class="listSubCat" id="Anno">(?P<block>.*)<ul class="listSubCat" id="Qualita">'
-    elif item.args == 'quality':
-        patronBlock = r'<ul class="listSubCat" id="Qualita">(?P<block>.*)<blockquote'
-    elif item.args == 'lucky': # sono i titoli random nella pagina
-        patronBlock = r'FILM RANDOM.*?class="listSubCat">(?P<block>.*)</ul>'
-        action = 'findvideos'
-    patronMenu = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<]+)<'
-
-    #debug = True
-    return locals()
-
-# =========== def per cercare film/serietv =============
-#host+/index.php?do=search&story=avatar&subaction=search
-def search(item, text):
-    support.info('search', item)
-    itemlist = []
-    text = text.replace(" ", "+")
-    item.url = host+"/index.php?do=search&story=%s&subaction=search" % (text)
-    try:
-        return peliculas(item)
-    # Se captura la excepcion, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-# =========== def per le novità nel menu principale =============
-
-def newest(categoria):
-    support.info('newest', categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "peliculas":
-            item.url = host
-            item.action = "peliculas"
-            item.contentType='movie'
-            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
-
-def findvideos(item):
-    support.info('findvideos', item)
-    return support.server(item, support.match(item, patron='<ul class="playernav">.*?</ul>', headers=headers).match)

channels/altadefinizioneclick.json

@@ -1,7 +1,7 @@
 {
     "id": "altadefinizioneclick",
     "name": "AltadefinizioneClick",
-    "active": true,
+    "active": false,
     "language": ["ita","sub-ita"],
     "thumbnail": "altadefinizioneclick.png",
     "bannermenu": "altadefinizioneciclk.png",

channels/altadefinizioneclick.py

@@ -1,107 +1,41 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Canale per altadefinizioneclick
+# Canale per Altadefinizione Click
 # ----------------------------------------------------------
-"""
 
-    Eccezioni che non superano il test del canale:
-       - indicare le eccezioni
-
-    Novità. Indicare in quale/i sezione/i è presente il canale:
-       - film
-    
-    Avvisi:
-        - Eventuali avvisi per i tester
-
-    Ulteriori info:
-
-
-"""
-from platformcode.logger import debug
 from core import support
-from core.item import Item
-from platformcode import config
+from platformcode import config, logger
 
 def findhost(url):
-    data = support.httptools.downloadpage(url).data
-    host = support.scrapertools.find_single_match(data, '<div class="elementor-button-wrapper">\s*<a href="([^"]+)"')
-    return host
+    return support.match(url, patron=r'<div class="elementor-button-wrapper">\s*<a href="([^"]+)"').match
 
 host = config.get_channel_url(findhost)
-headers = [['Referer', host]]
+if host.endswith('/'):
+        host = host[:-1]
+headers = {'Referer': host, 'x-requested-with': 'XMLHttpRequest'}
+order = ['', 'i_piu_visti', 'i_piu_votati', 'i_piu_votati_dellultimo_mese', 'titolo_az', 'voto_imdb_piu_alto'][config.get_setting('order', 'altadefinizionecommunity')]
 
 
 @support.menu
 def mainlist(item):
-    film = ['',
-        ('Novità', ['/nuove-uscite/', 'peliculas', 'news']),
-        ('Al Cinema', ['/al-cinema/', 'peliculas', 'cinema']),
-        ('A-Z',['/lista-film/', 'genres', 'az']),
-        ('Generi', ['', 'genres', 'genres']),
-        ('Anni', ['', 'genres', 'years']),
-        ('Qualità', ['', 'genres', 'quality']),
-        ('Mi sento Fortunato',[ '', 'genres', 'lucky']),
-        ('Sub-ITA', ['/sub-ita/', 'peliculas', 'sub'])
-    ]
+    logger.debug(item)
 
-    tvshow = ['/serie-tv/']
+    film = ['/type/movie',
+            ('Generi', ['/type/movie', 'genres', 'genres']),
+            ('Anni', ['/type/movie', 'genres', 'year']),]
 
-    search = ''
-    return locals()
-
-@support.scrape
-def peliculas(item):
-    action = 'check'
-
-    patron = r'<div class="wrapperImage">\s*(?:<span class="year">(?P<year>[^<]+)[^>]+>)?(?:<span class="hd">(?P<quality>[^<>]+))?.+?href="(?P<url>[^"]+)".+?src="(?P<thumb>[^"]+)".+?<h2 class="titleFilm">[^>]+>(?P<title>.+?)[ ]?(?:|\[(?P<lang>[^\]]+)\])?</a>.*?(?:IMDB\:</strong>[ ](?P<rating>.+?)<|</div>)'
-
-    if item.args == 'az':
-        patron = r'<img style="[^"]+" src="(?P<thumb>[^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="(?P<url>[^"]+)" [^>]+>(?P<title>[^<\[]+)(?:\[(?P<lang>[^\]]+)\]\s*)?<'\
-                 r'[^>]+>[^>]+>[^>]+>[^>]+>\s*(?P<year>\d{4})[^>]+>[^>]+>\s*(?P<quality>[^<]+).*?<span class="label">(?P<ratting>[^<]+)<'
-        patronBlock =''
-
-    elif item.args == 'search':
-        patronBlock = r'<section id="lastUpdate">(?P<block>.*?)(?:<div class="row ismobile">|<section)'
-        patron = r'<a href="(?P<url>[^"]+)">\s*<div class="wrapperImage">(?:\s*<span class="year">(?P<year>[^<]+)<\/span>)?(?:\s*<span class="hd">(?P<quality>[^<]+)<\/span>)?[^>]+>\s*<img[^s]+src="(?P<thumb>[^"]+)"(?:(?:[^>]+>){5}\s*(?P<rating>[^<]+))?(?:[^>]+>){4}(?P<title>[^<]+)'
-
-    if not item.args:
-        # patronBlock = r'(?:ULTIMI INSERITI|Serie TV)(?P<block>.*?)</section'
-        patronBlock = r'({})(?P<block>.*?)</section'.format('ULTIMI INSERITI' if item.contentType == 'movie' else 'Serie TV')
-
-    # nella pagina "CERCA", la voce "SUCCESSIVO" apre la maschera di inserimento dati
-    patronNext = r'<a class="next page-numbers" href="([^"]+)">'
+    tvshow = ['/serie-tv/tvshow',
+              ('Generi', ['/serie-tv/tvshow', 'genres', 'genres']),
+              ('Anni', ['/serie-tv/tvshow', 'genres', 'year'])]
 
     return locals()
 
-@support.scrape
-def genres(item):
-    action = 'peliculas'
-    patronMenu = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<]+)<'
-
-    if item.args == 'genres':
-        patronBlock = r'<ul class="listSubCat" id="Film">(?P<block>.*)<ul class="listSubCat" id="Anno">'
-    elif item.args == 'years':
-        patronBlock = r'<ul class="listSubCat" id="Anno">(?P<block>.*)<ul class="listSubCat" id="Qualita">'
-    elif item.args == 'quality':
-        patronBlock = r'<ul class="listSubCat" id="Qualita">(?P<block>.*)</li>\s*?</ul>\s*?</div>\s*?</div>\s*?</div>\s*?<a'
-    elif item.args == 'lucky': # sono i titoli random nella pagina
-        patronBlock = r'<h3 class="titleSidebox dado">FILM RANDOM</h3>(?P<block>.*)</section>'
-        patron = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<[]+)(?:\[(?P<lang>.+?)\])?<'
-        action = 'findvideos'
-    elif item.args == 'az':
-        blacklist = ['FILM 4K IN STREAMING']
-        patron = r'<a title="(?P<title>[^"]+)" href="(?P<url>[^"]+)"'
-        item.args = 'az'
-    if not item.args == 'az':
-        item.args = 'genres'
-
-    return locals()
 
 def search(item, texto):
-    support.info("search ", texto)
+    logger.debug("search ", texto)
 
     item.args = 'search'
-    item.url = host + "?s=" + texto
+    item.url = host + "/search?s={}&f={}&page=1".format(texto, item.contentType)
     try:
         return peliculas(item)
     # Continua la ricerca in caso di errore
@@ -111,87 +45,107 @@ def search(item, texto):
             support.logger.error("%s" % line)
         return []
 
-def newest(categoria):
-    support.info(categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "peliculas":
-            item.args = 'news'
-            item.contentType = 'movie'
-            item.url = host + "/nuove-uscite/"
-            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():
-            from platformcode import logger
-            logger.error("{0}".format(line))
-        return []
-
-    return itemlist
-
-
-def check(item):
-    item.contentType = 'tvshow'
-    def get_season(pageData, seas_url, season):
-        data = ''
-        episodes = support.match(pageData if pageData else seas_url, patronBlock=patron_episode, patron=patron_option).matches
-        for episode_url, episode in episodes:
-            # episode_url = support.urlparse.urljoin(item.url, episode_url)
-            # if '-' in episode: episode = episode.split('-')[0].zfill(2) + 'x' + episode.split('-')[1].zfill(2)
-            title = season + "x" + episode.zfill(2) + ' - ' + item.fulltitle
-            data += title + '|' + episode_url + '\n'
-        return data
-
-    patron_season = '<div class="[^"]+" id="seasonsModal"[^>]+>(.*?)</ul>'
-    patron_episode = '<div class="[^"]+" id="episodesModal"[^>]+>(.*?)</ul>'
-    patron_option = r'<a href="([^"]+?)".*?>(?:Stagione |Episodio )([^<]+?)</a>'
-
-    url = support.match(item, patron=r'<iframe id="iframeVid" width="[^"]+" height="[^"]+" src="([^"]+)" allowfullscreen').match
-    seasons = support.match(url, patronBlock=patron_season, patron=patron_option)
-    if not seasons.match:
-        item.contentType = 'movie'
-        return findvideos(item)
-
-    data = ''
-
-    import sys
-    if sys.version_info[0] >= 3: from concurrent import futures
-    else: from concurrent_py2 import futures
-    with futures.ThreadPoolExecutor() as executor:
-        thL = []
-        for i, season in enumerate(seasons.matches):
-            thL.append(executor.submit(get_season, seasons.data if i == 0 else '', season[0], season[1]))
-        for res in futures.as_completed(thL):
-            if res.result():
-                data += res.result()
-    item.data = data
-    return episodios(item)
 
 @support.scrape
-def episodios(item):
-    data = item.data
+def genres(item):
+    logger.debug(item)
+    data = support.httptools.downloadpage(item.url, cloudscraper=True).data
+    blacklist= ['Film', 'Serie TV']
 
-    patron = r'(?P<season>\d+)x(?P<episode>\d+)\s*-\s*(?P<title>[^\|]+)\|(?P<url>[^ ]+)'
+    if item.args == 'genres':
+        categories ={}
+        res = support.match(host + '/cerca', patron=r'for="cat-(\d+)[^>]+>([^<]+)').matches
+        for _id, name in res:
+            categories[name] = _id
+
+        patronBlock = r'{}<span></span>(?P<block>.*?)</ul>\s*</li'.format('Film' if item.contentType == 'movie' else 'Serie TV')
+        patronMenu = r'<a href="[^"]+">(?P<title>[^<]+)'
+
+        def itemHook(it):
+            it.cat_id = categories[it.fulltitle]
+            return it
+
+    if item.args == 'year':
+        patron = r'value="(?P<year_id>[^"]+)"[^>]*>(?P<title>\d+)'
+        patronBlock = r'Anno</option>(?P<block>.*?</select>)'
+
+    elif item.args == 'quality':
+        patronMenu = r'quality/(?P<quality_id>[^"]+)">(?P<title>[^<]+)'
+        patronBlock = r'Risoluzione(?P<block>.*?)</ul>'
+    action = 'peliculas'
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    item.quality = 'HD'
+    json = {}
+    params ={'type':item.contentType, 'anno':item.year_id, 'quality':item.quality_id, 'cat':item.cat_id, 'order':order}
+
+
+    if item.contentType == 'movie':
         action = 'findvideos'
+    else:
+        action = 'episodios'
+    if not item.page: item.page = 1
+    try:
+        # support.dbg()
+        if item.args in ['search']:
+            page = support.httptools.downloadpage(item.url, headers=headers)
+            if page.json:
+                data = "\n".join(page.json['data'])
+            else:
+                data = page.data
+        else:
+            params['page'] = item.page
 
-    def itemlistHook(itemlist):
-        itemlist.sort(key=lambda item: (item.infoLabels['season'], item.infoLabels['episode']))
+            url = '{}/load-more-film?{}'.format(host, support.urlencode(params))
+            json = support.httptools.downloadpage(url, headers=headers).json
+            data = "\n".join(json['data'])
+    except:
+        data = ' '
+
+    patron = r'wrapFilm">\s*<a href="(?P<url>[^"]+)">[^>]+>(?P<year>\d+)(?:[^>]+>){2}(?P<rating>[^<]+)(?:[^>]+>){4}\s*<img src="(?P<thumb>[^"]+)(?:[^>]+>){3}(?P<title>[^<[]+)(?:\[(?P<lang>[sSuUbBiItTaA-]+))?'
+    # patron = r'wrapFilm">\s*<a href="(?P<url>[^"]+)">[^>]+>(?P<year>\d+)(?:[^>]+>){2}(?P<rating>[^<]+)(?:[^>]+>){2}(?P<quality>[^<]+)(?:[^>]+>){2}\s*<img src="(?P<thumb>[^"]+)(?:[^>]+>){3}(?P<title>[^<[]+)(?:\[(?P<lang>[sSuUbBiItTaA-]+))?'
+
+    # paginazione
+    if json.get('have_next') or 'have_next_film=true' in data:
+        def fullItemlistHook(itemlist):
+            cat_id = support.match(data, patron=r''''cat':"(\d+)"''').match
+            if cat_id: item.cat_id = cat_id
+            item.page += 1
+            support.nextPage(itemlist, item, function_or_level='peliculas')
             return itemlist
 
     return locals()
 
-def findvideos(item):
-    support.info('findvideos', item)
-    return support.hdpass_get_servers(item)
 
-# def play(item):
-#     if 'hdpass' in item.url:
-#         return support.hdpass_get_url(item)
-#     return [item]
+@support.scrape
+def episodios(item):
+    logger.debug(item)
+    # debug = True
+    data = item.data
+    patron = r'class="playtvshow "\s+data-href="(?P<url>[^"]+)'
+
+    def itemHook(it):
+        spl = it.url.split('/')[-2:]
+        it.infoLabels['season'] = int(spl[0])+1
+        it.infoLabels['episode'] = int(spl[1])+1
+        it.url = it.url.replace('/watch-unsubscribed', '/watch-external')
+        it.title = '{}x{:02d} - {}'.format(it.contentSeason, it.contentEpisodeNumber, it.fulltitle)
+        return it
+
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    playWindow = support.match(item, patron='(?:playWindow|iframe)" (?:href|src)="([^"]+)').match
+    if host in playWindow:
+        url = support.match(playWindow, patron='allowfullscreen[^<]+src="([^"]+)"').match
+    else:
+        url = playWindow
+    itemlist.append(item.clone(action='play', url=url, quality=''))
+
+
+    return support.server(item, itemlist=itemlist)

channels/altadefinizionecommunity.json

@@ -2,7 +2,7 @@
     "id": "altadefinizionecommunity",
     "name": "Altadefinizione Community",
     "language": ["ita", "sub-ita"],
-    "active": true,
+    "active": false,
     "thumbnail": "altadefinizionecommunity.png",
     "banner": "",
     "categories": ["movie", "tvshow", "vos"],
@@ -23,5 +23,15 @@
       "label": "password",
       "type": "text",
       "visible": true
-    }]
+    },
+    {
+      "id": "order",
+      "type": "list",
+      "label": "Ordine di Visualizzazione",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [ "Nessuno", "I più visti", "I più votati", "I più votati dell'ultimo mese", "Titolo A-Z", "Voto IMDB più alto"]
+    }
+  ]
 }

channels/altadefinizionecommunity.py

@@ -13,38 +13,184 @@ def findhost(url):
 
 
 host = config.get_channel_url(findhost)
-register_url = 'https://altaregistrazione.com'
-headers = {'Referer': host, 'x-requested-with': 'XMLHttpRequest'}
+register_url = 'https://altaregistrazione.net'
+
+if 'altadefinizionecommunity' not in host:
+    config.get_channel_url(findhost, forceFindhost=True)
+
+if host.endswith('/'):
+    host = host[:-1]
+
+headers = {'Referer': host}
+order = ['', 'i_piu_visti', 'i_piu_votati', 'i_piu_votati_dellultimo_mese', 'titolo_az', 'voto_imdb_piu_alto'][config.get_setting('order', 'altadefinizionecommunity')]
 
 
 @support.menu
 def mainlist(item):
     logger.debug(item)
 
-    film = ['/load-more-film?anno=&order=&support_webp=1&type=movie&page=1',
-        # Voce Menu,['url','action','args',contentType]
-        ('Generi Film', ['', 'genres', 'genres']),
-        ]
+    film = ['/type/movie',
+            ('Generi', ['/type/movie', 'genres', 'genres']),
+            ('Anni', ['/type/movie', 'genres', 'year']),]
 
-    tvshow = ['/load-more-film?type=tvshow&anno=&order=&support_webp=1&page=1',
-        # Voce Menu,['url','action','args',contentType]
-        ('Generi Serie TV', ['', 'genres', 'genres']),
-        ]
-
-    altri = [
-        # ('A-Z', ['/lista-film', 'genres', 'letters']),
-        ('Qualità', ['', 'genres', 'quality']),
-        ('Anni', ['/anno', 'genres', 'years'])
-    ]
-    search = ''
+    tvshow = ['/serie-tv/tvshow',
+              ('Generi', ['/serie-tv/tvshow', 'genres', 'genres']),
+              ('Anni', ['/serie-tv/tvshow', 'genres', 'year'])]
 
     return locals()
 
 
+def search(item, text):
+    logger.debug("search ", text)
+    # per evitare fastidi da ricerca globale
+    if not item.globalsearch:
+        registerOrLogin()
+
+    item.args = 'search'
+    item.url = host + "/search?s={}&f={}".format(text.replace(' ', '+'), item.contentType)
+    try:
+        return peliculas(item)
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.logger.error("%s" % line)
+        return []
+
+
+@support.scrape
+def genres(item):
+    registerOrLogin()
+    logger.debug(item)
+    data = support.httptools.downloadpage(item.url).data
+    blacklist= ['Film', 'Serie TV']
+
+    if item.args == 'genres':
+        categories ={}
+        res = support.match(host + '/cerca', patron=r'for="cat-(\d+)[^>]+>([^<]+)').matches
+        for _id, name in res:
+            categories[name] = _id
+
+        patronBlock = r'{}<span></span>(?P<block>.*?)</ul>\s*</li'.format('Film' if item.contentType == 'movie' else 'Serie TV')
+        patronMenu = r'<a href="[^"]+">(?P<title>[^<]+)'
+
+        def itemHook(it):
+            it.cat_id = categories[it.fulltitle]
+            return it
+
+    if item.args == 'year':
+        patronMenu = r'value="(?P<year_id>[^"]+)"[^>]*>(?P<title>\d+)'
+        patronBlock = r'Anno</option>(?P<block>.*?</select>)'
+
+    elif item.args == 'quality':
+        patronMenu = r'quality/(?P<quality_id>[^"]+)">(?P<title>[^<]+)'
+        patronBlock = r'Risoluzione(?P<block>.*?)</ul>'
+
+    action = 'peliculas'
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    item.quality = 'HD'
+    json = {}
+    if not item.page: item.page = 1
+    params ={'type':item.contentType, 'anno':item.year_id, 'quality':item.quality_id, 'cat':item.cat_id, 'order':order, 'page':item.page}
+    # debug = True
+
+    action = 'findvideos' if item.contentType == 'movie' else 'episodios'
+
+    try:
+        # support.dbg()
+        if item.args in ['search']:
+            page = support.httptools.downloadpage(item.url, headers=headers)
+            if page.json:
+                data = "\n".join(page.json['data'])
+            else:
+                data = page.data
+        else:
+            params['page'] = item.page
+
+            url = '{}/load-more-film?{}'.format(host, support.urlencode(params))
+            json = support.httptools.downloadpage(url, headers=headers).json
+            data = "\n".join(json['data'])
+    except:
+        data = ' '
+
+    patron = r'wrapFilm"[^>]*>\s*<a href="(?P<url>[^"]+)">[^>]+>(?P<year>\d+)(?:[^>]+>){2}(?P<rating>[^<]+)(?:[^>]+>){4}\s*<img src="(?P<thumb>[^"]+)(?:[^>]+>){2,6}\s+<h3>(?P<title>[^<[]+)(?:\[(?P<lang>[sSuUbBiItTaA -]+))?'
+    # patron = r'wrapFilm">\s*<a href="(?P<url>[^"]+)">[^>]+>(?P<year>\d+)(?:[^>]+>){2}(?P<rating>[^<]+)(?:[^>]+>){4}\s*<img src="(?P<thumb>[^"]+)(?:[^>]+>){3}(?P<title>[^<[]+)(?:\[(?P<lang>[sSuUbBiItTaA-]+))?'
+
+    def itemHook(item):
+        item.quality = item.quality.replace('2K', 'HD').replace('4K', 'HD')
+        item.title = item.title.replace('2K', 'HD').replace('4K', 'HD')
+        return item
+
+    # paginazione
+    if json.get('have_next') or support.match(data, patron=r'have_next_film\s*=\s*true').match:
+        def fullItemlistHook(itemlist):
+            cat_id = support.match(data, patron=r''''cat':"(\d+)"''').match
+            if cat_id: item.cat_id = cat_id
+            item.page += 1
+            support.nextPage(itemlist, item, function_or_level='peliculas')
+            return itemlist
+
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    registerOrLogin()
+    logger.debug(item)
+    # debug = True
+    data = item.data
+    patron = r'class="playtvshow "\s+data-href="(?P<url>[^"]+)'
+
+    def itemHook(it):
+        spl = it.url.split('/')[-2:]
+        it.infoLabels['season'] = int(spl[0])+1
+        it.infoLabels['episode'] = int(spl[1])+1
+        it.url = it.url.replace('/watch-unsubscribed', '/watch-external')
+        it.title = '{}x{:02d} - {}'.format(it.contentSeason, it.contentEpisodeNumber, it.fulltitle)
+        return it
+
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    resolve_url(item)
+
+    itemlist.append(item.clone(action='play', url=support.match(item.url, patron='allowfullscreen[^<]+src="([^"]+)"', cloudscraper=True).match, quality=''))
+
+    return support.server(item, itemlist=itemlist)
+
+
+def play(item):
+    if host in item.url:  # intercetto il server proprietario
+        # if registerOrLogin():
+        return support.get_jwplayer_mediaurl(support.httptools.downloadpage(item.url, cloudscraper=True).data, 'Diretto')
+        # else:
+        #     platformtools.play_canceled = True
+        #     return []
+    else:
+        return [item]
+
+
+def resolve_url(item):
+    registerOrLogin()
+    if '/watch-unsubscribed' not in item.url and '/watch-external' not in item.url:
+        playWindow = support.match(support.httptools.downloadpage(item.url, cloudscraper=True).data, patron='playWindow" href="([^"]+)')
+        video_url = playWindow.match
+        item.data = playWindow.data
+        item.url = video_url.replace('/watch-unsubscribed', '/watch-external')
+    return item
+
+
 def login():
     r = support.httptools.downloadpage(host, cloudscraper=True)
     Token = support.match(r.data, patron=r'name=\s*"_token"\s*value=\s*"([^"]+)', cloudscraper=True).match
-    if 'id="logged"' in r.text:
+    if 'id="logged"' in r.data:
         logger.info('Già loggato')
     else:
         logger.info('Login in corso')
@@ -54,11 +200,11 @@ def login():
                 'password':config.get_setting('password', channel='altadefinizionecommunity')}
 
         r = support.httptools.downloadpage(host + '/login', post=post, headers={'referer': host}, cloudscraper=True)
-        if not r.status_code in [200, 302] or 'Email o Password non validi' in r.text:
+        if r.code not in [200, 302] or 'Email o Password non validi' in r.data:
             platformtools.dialog_ok('AltadefinizioneCommunity', 'Username/password non validi')
             return False
 
-    return 'id="logged"' in r.text
+    return 'id="logged"' in r.data
 
 
 def registerOrLogin():
@@ -125,128 +271,3 @@ def registerOrLogin():
         return False
 
     return True
-
-
-@support.scrape
-def peliculas(item):
-    json = {}
-
-    if item.contentType == 'undefined':
-        disabletmdb = True
-        action = 'check'
-    elif item.contentType == 'movie':
-        action = 'findvideos'
-    else:
-        action = 'episodios'
-
-    if '/load-more-film' not in item.url and '/search' not in item.url:  # generi o altri menu, converto
-        import ast
-        ajax = support.match(item.url, patron='ajax_data\s*=\s*"?\s*([^;]+)', cloudscraper=True).match
-        item.url = host + '/load-more-film?' + support.urlencode(ast.literal_eval(ajax)) + '&page=1'
-    if not '/search' in item.url:
-        json = support.httptools.downloadpage(item.url, headers=headers, cloudscraper=True).json
-        data = "\n".join(json['data'])
-    else:
-        json = support.httptools.downloadpage(item.url, headers=headers, cloudscraper=True).json
-        data = "\n".join(json['data'])
-    patron = r'wrapFilm">\s*<a href="(?P<url>[^"]+)">\s*<span class="year">(?P<year>[0-9]{4})</span>\s*<span[^>]+>[^<]+</span>\s*<span class="qual">(?P<quality>[^<]+).*?<img src="(?P<thumbnail>[^"]+)[^>]+>\s*<h3>(?P<title>[^<[]+)(?:\[(?P<lang>[sSuUbBiItTaA-]+))?'
-
-    # paginazione
-    if json.get('have_next'):
-        def fullItemlistHook(itemlist):
-            spl = item.url.split('=')
-            url = '='.join(spl[:-1])
-            page = str(int(spl[-1])+1)
-            support.nextPage(itemlist, item, next_page='='.join((url, page)), function_or_level='peliculas')
-            return itemlist
-
-    return locals()
-
-
-def search(item, texto):
-    logger.debug("search ", texto)
-
-    item.args = 'search'
-    item.url = host + "/search?s={}&page=1".format(texto)
-    try:
-        return peliculas(item)
-    # Continua la ricerca in caso di errore
-    except:
-        import sys
-        for line in sys.exc_info():
-            support.logger.error("%s" % line)
-        return []
-
-
-@support.scrape
-def genres(item):
-    logger.debug(item)
-    data = support.httptools.downloadpage(item.url, cloudscraper=True).data
-
-    patronMenu = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)'
-    if item.args == 'quality':
-        item.contentType = 'undefined'
-        patronBlock = r'Risoluzione(?P<block>.*?)</ul>'
-    elif item.args == 'years':
-        item.contentType = 'undefined'
-        patronBlock = r'ANNO(?P<block>.*?</section>)'
-    else:
-        patronBlock = ('Film' if item.contentType == 'movie' else 'Serie TV') + r'<span></span></a>\s+<ul class="dropdown-menu(?P<block>.*?)active-parent-menu'
-    action = 'peliculas'
-    return locals()
-
-
-@support.scrape
-def episodios(item):
-    logger.debug(item)
-    data = item.data
-    patron = r'class="playtvshow " data-href="(?P<url>[^"]+)'
-
-    def itemHook(it):
-        spl = it.url.split('/')[-2:]
-        it.infoLabels['season'] = int(spl[0])+1
-        it.infoLabels['episode'] = int(spl[1])+1
-        it.url = it.url.replace('/watch-unsubscribed', '/watch-external')
-        it.title = '{}x{:02d} - {}'.format(it.contentSeason, it.contentEpisodeNumber, it.fulltitle)
-        return it
-
-    return locals()
-
-
-def check(item):
-    resolve_url(item)
-    if '/tvshow' in item.url:
-        item.contentType = 'tvshow'
-        return episodios(item)
-    else:
-        item.contentType = 'movie'
-        return findvideos(item)
-
-
-def findvideos(item):
-    itemlist = []
-    resolve_url(item)
-
-    itemlist.append(item.clone(action='play', url=support.match(item.url, patron='allowfullscreen[^<]+src="([^"]+)"', cloudscraper=True).match, quality=''))
-
-    return support.server(item, itemlist=itemlist)
-
-
-def play(item):
-    if host in item.url:  # intercetto il server proprietario
-        if registerOrLogin():
-            return support.get_jwplayer_mediaurl(support.httptools.downloadpage(item.url, cloudscraper=True).data, 'Diretto')
-        else:
-            platformtools.play_canceled = True
-            return []
-    else:
-        return [item]
-
-
-def resolve_url(item):
-    if '/watch-unsubscribed' not in item.url and '/watch-external' not in item.url:
-        playWindow = support.match(support.httptools.downloadpage(item.url, cloudscraper=True).data, patron='playWindow" href="([^"]+)')
-        video_url = playWindow.match
-        item.data = playWindow.data
-        item.url = video_url.replace('/watch-unsubscribed', '/watch-external')
-    return item

channels/animealtadefinizione.json

@@ -1,7 +1,7 @@
 {
     "id": "animealtadefinizione",
     "name": "AnimealtAdefinizione",
-    "active": true,
+    "active": false,
     "language": ["ita", "sub-ita"],
     "thumbnail": "animealtadefinizione.png",
     "banner": "animealtadefinizione.png",

channels/animealtadefinizione.py

@@ -10,7 +10,7 @@ headers = [['Referer', host]]
 
 perpage_list = ['20','30','40','50','60','70','80','90','100']
 perpage = perpage_list[support.config.get_setting('perpage' , 'animealtadefinizione')]
-epPatron = r'<td>\s*(?P<title>[^<]+)[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)"'
+epPatron = r'<td>\s*(?P<title>[^<]+)[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>\s*<img[^>]+/Streaming'
 
 
 @support.menu
@@ -67,7 +67,7 @@ def peliculas(item):
         action='findvideos'
     elif item.args == 'last':
         item.contentType = 'episode'
-        action='findvideos'
+        action='episodios'
     else:
         item.contentType = 'tvshow'
         action='episodios'
@@ -85,6 +85,10 @@ def peliculas(item):
     typeContentDict = {'movie':['movie']}
     typeActionDict = {'findvideos':['movie']}
 
+    def itemHook(item):
+        item.url = support.re.sub('episodio-[0-9-]+', '', item.url)
+        return item
+
     def itemlistHook(itemlist):
         if item.search:
             itemlist = [ it for it in itemlist if ' Episodio ' not in it.title ]
@@ -98,6 +102,7 @@ def peliculas(item):
 @support.scrape
 def episodios(item):
     anime = True
+    # debug = True
     pagination = int(perpage)
     patron = epPatron
     return locals()

channels/animeforce.json

@@ -2,7 +2,7 @@
 	"id": "animeforce",
 	"name": "AnimeForce",
 	"language": ["ita"],
-	"active": true,
+	"active": false,
 	"thumbnail": "animeforce.png",
 	"banner": "animeforce.png",
 	"categories": ["anime"],

channels/animeforce.py

@@ -11,7 +11,7 @@ headers = [['Referer', host]]
 
 @support.menu
 def mainlist(item):
-    anime = ['/lista-anime/',
+    anime = ['/anime',
              ('In Corso',['/anime/anime-status/in-corso/', 'peliculas', 'status']),
              ('Completi',['/anime/anime-status/completo/', 'peliculas', 'status']),
              ('Genere',['/anime', 'submenu', 'genre']),
@@ -27,9 +27,10 @@ def mainlist(item):
 def submenu(item):
     action = 'peliculas'
     patronBlock = r'data-taxonomy="' + item.args + r'"(?P<block>.*?)</select'
-    patronMenu = r'<option class="level-\d+ (?P<u>[^"]+)"[^>]+>(?P<t>[^(]+)[^\(]+\((?P<num>\d+)'
+    patronMenu = r'<option class="level-\d+ (?P<url>[^"]+)"[^>]+>(?P<t>[^(]+)[^\(]+\((?P<num>\d+)'
     def itemHook(item):
-        item.url += host + '/anime/' + item.args + '/' + item.u
+        if not item.url.startswith('http'):
+            item.url = host + '/anime/' + item.args + '/' + item.url
         item.title = support.typo(item.t, 'bold')
         return item
     return locals()
@@ -73,19 +74,17 @@ def search(item, text):
 def peliculas(item):
     search = item.search
     anime = True
-    if 'movie' in item.url:
-        action = 'findvideos'
-    else:
     action = 'check'
 
-    if not item.args:
-        pagination = ''
-        patron = r'<a\s*href="(?P<url>[^"]+)"\s*title="(?P<title>[^"]+)">'
-    else:
     patron = r'<a href="(?P<url>[^"]+)"[^>]+>\s*<img src="(?P<thumb>[^"]+)" alt="(?P<title>.*?)(?: Sub| sub| SUB|")'
 
+    if search:
+        patron = r'<a href="(?P<url>[^"]+)"\s*title="(?P<title>.*?)(?: Sub| sub| SUB|")'
+
     if item.args == 'newest': item.action = 'findvideos'
 
+    patronNext = '<li class="page-item disabled">(?:[^>]+>){4}<a class="page-link" href="([^"]+)'
+
     def itemHook(item):
         if 'sub-ita' in item.url:
             if item.args != 'newest': item.title = item.title + support.typo('Sub-ITA','_ [] color kod')
@@ -96,7 +95,7 @@ def peliculas(item):
 
 
 def check(item):
-    m = support.match(item, headers=headers, patron=r'Tipologia[^>]+><a href="([^"]+)"')
+    m = support.match(item, headers=headers, patron=r'Tipologia[^>]+>\s*<a href="([^"]+)"')
     item.data = m.data
     if 'movie' in m.match:
         item.contentType = 'movie'
@@ -108,12 +107,13 @@ def check(item):
 @support.scrape
 def episodios(item):
     anime = True
+    pagination = 50
     data = item.data
 
     if '<h6>Streaming</h6>' in data:
-        patron = r'<td style[^>]+>\s*.*?(?:<span[^>]+)?<strong>(?P<title>[^<]+)<\/strong>.*?<td style[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>'
+        patron = r'<td style[^>]+>\s*.*?(?:<span[^>]+)?<strong>(?P<title>[^<]+)<\/strong>.*?<td style[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>(?P<episode>\d+)'
     else:
-        patron = r'<a\s*href="(?P<url>[^"]+)"\s*title="(?P<title>[^"]+)"\s*class="btn btn-dark mb-1">'
+        patron = r'<a\s*href="(?P<url>[^"]+)"\s*title="(?P<title>[^"]+)"\s*class="btn btn-dark mb-1">(?P<episode>\d+)'
     def itemHook(item):
         support.info(item)
         if item.url.startswith('//'): item.url= 'https:' + item.url
@@ -126,29 +126,36 @@ def episodios(item):
 def findvideos(item):
     support.info(item)
     itemlist = []
-
-    if 'adf.ly' in item.url:
-        from servers.decrypters import adfly
-        url = adfly.get_long_url(item.url)
-
-    elif 'bit.ly' in item.url:
-        url = support.httptools.downloadpage(item.url, only_headers=True, follow_redirects=False).headers.get("location")
-
+    if item.data:
+        url = support.match(item.data, patron=r'<a\s*href="([^"]+)"\s*title="[^"]+"\s*class="btn btn-dark mb-1">').match
     else:
-        url = host
-        for u in item.url.split('/'):
-            if u and 'animeforce' not in u and 'http' not in u:
-                url += '/' + u
+        url = item.url
 
-        if 'php?' in url:
-            url = support.httptools.downloadpage(url, only_headers=True, follow_redirects=False).headers.get("location")
-            url = support.match(url, patron=r'class="button"><a href=(?:")?([^" ]+)', headers=headers).match
-        else:
-            if item.data: url = item.data
+    # if 'adf.ly' in item.url:
+    #     from servers.decrypters import adfly
+    #     url = adfly.get_long_url(item.url)
+
+    # elif 'bit.ly' in item.url:
+    #     url = support.httptools.downloadpage(item.url, only_headers=True, follow_redirects=False).headers.get("location")
+
+    # else:
+    #     url = host
+    #     for u in item.url.split('/'):
+    #         if u and 'animeforce' not in u and 'http' not in u:
+    #             url += '/' + u
+
+
+    #     if 'php?' in url:
+    #         url = support.httptools.downloadpage(url, only_headers=True, follow_redirects=False).headers.get("location")
+    #         url = support.match(url, patron=r'class="button"><a href=(?:")?([^" ]+)', headers=headers).match
+    #     else:
+    #         if item.data: url = item.data
+    #         if item.contentType == 'movie': url = support.match()
+    #         url = support.match(url, patron=r'data-href="([^"]+)" target').match
+    #         if not url: url = support.match(url, patron=[r'<source src=(?:")?([^" ]+)',r'name="_wp_http_referer" value="([^"]+)"']).match
+    #     if url.startswith('//'): url = 'https:' + url
+    #     elif url.startswith('/'): url = 'https:/' + url
     url = support.match(url, patron=r'data-href="([^"]+)" target').match
-            if not url: url = support.match(url, patron=[r'<source src=(?:")?([^" ]+)',r'name="_wp_http_referer" value="([^"]+)"']).match
-        if url.startswith('//'): url = 'https:' + url
-        elif url.startswith('/'): url = 'https:/' + url
     if 'vvvvid' in url: itemlist.append(item.clone(action="play", title='VVVVID', url=url, server='vvvvid'))
     else: itemlist.append(item.clone(action="play", title=support.config.get_localized_string(30137), url=url, server='directo'))
 

channels/animeleggendari.json

@@ -1,11 +0,0 @@
-{
-    "id": "animeleggendari",
-    "name": "AnimePerTutti",
-    "active": false,
-    "language": ["ita", "sub-ita"],
-    "thumbnail": "animepertutti.png",
-    "bannermenu": "animepertutti.png",
-    "categories": ["anime", "vos"],
-    "not_active":["include_in_newest_peliculas", "include_in_newest_series", "include_in_newest_anime"],
-    "settings": []
-}

channels/animeleggendari.py

@@ -1,141 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per animeleggendari
-# ------------------------------------------------------------
-
-from core import support
-from lib.js2py.host import jsfunctions
-
-host = support.config.get_channel_url()
-
-headers = [['User-Agent', 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0'],
-           ['Referer', host]]
-
-
-
-
-
-@support.menu
-def mainlist(item):
-
-    anime = [
-        # ('Leggendari', ['/category/anime-leggendari/', 'peliculas']),
-        ('ITA', ['/category/anime-ita/', 'peliculas']),
-        ('SUB-ITA', ['/category/anime-sub-ita/', 'peliculas']),
-        ('Conclusi', ['/category/serie-anime-concluse/', 'peliculas']),
-        ('in Corso', ['/category/serie-anime-in-corso/', 'peliculas']),
-        ('Genere', ['', 'genres'])
-    ]
-
-    return locals()
-
-
-def search(item, texto):
-    support.info(texto)
-
-    item.url = host + "/?s=" + texto
-    try:
-        return peliculas(item)
-
-    # Continua la ricerca in caso di errore
-    except:
-        import sys
-        for line in sys.exc_info():
-            support.logger.error("%s" % line)
-        return []
-
-
-@support.scrape
-def genres(item):
-    blacklist = ['Contattaci','Privacy Policy', 'DMCA']
-    patronMenu = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)<'
-    patronBlock = r'Generi</a>\s*<ul[^>]+>(?P<block>.*?)<\/ul>'
-    action = 'peliculas'
-    return locals()
-
-
-@support.scrape
-def peliculas(item):
-    anime = True
-    blacklist = ['top 10 anime da vedere']
-    if item.url != host: patronBlock = r'<div id="main-content(?P<block>.*?)<aside'
-    patron = r'<figure class="(?:mh-carousel-thumb|mh-posts-grid-thumb)">\s*<a (?:class="[^"]+" )?href="(?P<url>[^"]+)" title="(?P<title>.*?)(?: \((?P<year>\d+)\))? (?:(?P<lang>SUB ITA|ITA))(?: (?P<title2>[Mm][Oo][Vv][Ii][Ee]))?[^"]*"><img (?:class="[^"]+"|width="[^"]+" height="[^"]+") src="(?P<thumb>[^"]+)"[^>]+'
-    def itemHook(item):
-        if 'movie' in item.title.lower():
-            item.title = support.re.sub(' - [Mm][Oo][Vv][Ii][Ee]|[Mm][Oo][Vv][Ii][Ee]','',item.title)
-            item.title += support.typo('Movie','_ () bold')
-            item.contentType = 'movie'
-            item.action = 'findvideos'
-        return item
-    def itemlistHook(itemlist):
-        itlist = []
-        for item in itemlist:
-            if 'nuovo episodio:' not in item.title.lower():
-                itlist += [item]
-        return itlist
-
-    patronNext = r'<a class="next page-numbers" href="([^"]+)">'
-    action = 'episodios'
-    return locals()
-
-
-@support.scrape
-def episodios(item):
-    data = support.match(item, headers=headers, patronBlock=r'entry-content clearfix">(.*?)class="mh-widget mh-posts-2 widget_text').block
-    if not 'pagination clearfix' in data:
-        support.info('NOT IN DATA')
-        patron = r'<iframe.*?src="(?P<url>[^"]+)"'
-        title = item.title
-        def fullItemlistHook(itemlist):
-            if len(itemlist) > 0:
-                urls = []
-                for item in itemlist:
-                    urls.append(item.url)
-                item = itemlist[0]
-                item.data = urls
-                item.title = title
-                item.contentType = 'movie'
-                itemlist = []
-                itemlist.append(item)
-            return itemlist
-    else:
-        url = item.url
-        anime = True
-        patronBlock = r'(?:<p style="text-align: left;">|<div class="pagination clearfix">\s*)(?P<block>.*?)</span></a></div>'
-        patron = r'(?:<a href="(?P<url>[^"]+)"[^>]+>)?<span class="pagelink">(?P<episode>\d+)'
-        def itemHook(item):
-            if not item.url:
-                item.url = url
-            if 'Movie Parte' in data:
-                item.title = support.typo(item.fulltitle + ' - Part ','bold') + item.title
-                item.contentType = 'movie'
-            else:
-                item.title = support.typo('Episodio ', 'bold') + item.title
-            return item
-    return locals()
-
-def check(item):
-    data = support.match(item, headers=headers).data
-    if 'Lista Episodi' not in data:
-        item.data = data
-        return findvideos(item)
-
-    data = ''
-    return data
-
-def findvideos(item):
-    support.info()
-    if item.data:
-        data = item.data
-    else:
-        matches = support.match(item, patron=r'<iframe.*?src="(?P<url>[^"]+)"').matches
-        data = ''
-        if matches:
-            for match in matches:
-                try: data += str(jsfunctions.unescape(support.re.sub('@|g','%', match)))
-                except: data += ''
-                data += str(match)
-        else:
-            data = ''
-
-    return support.server(item,data)

channels/animesaturn.py

@@ -3,9 +3,9 @@
 # Canale per AnimeSaturn
 # ----------------------------------------------------------
 
-from lib import js2py
 from core import support
-from platformcode import config
+from platformcode import logger
+import pyaes
 
 host = support.config.get_channel_url()
 __channel__ = 'animesaturn'
@@ -15,25 +15,30 @@ headers = {'X-Requested-With': 'XMLHttpRequest', 'Cookie': cookie}
 
 def get_cookie(data):
     global cookie, headers
-    cookie = support.match(data, patron=r'document.cookie="([^\s]+)').match
+    a = support.match(data, patron=r'a=toNumbers\("([^"]+?)"\)').match 
+    b = support.match(data, patron=r'b=toNumbers\("([^"]+?)"\)').match 
+    c = support.match(data, patron=r'c=toNumbers\("([^"]+?)"\)').match
+    
+    aes = pyaes.AESModeOfOperationCBC(bytes.fromhex(a), iv = bytes.fromhex(b))
+    
+    cookie = "ASNew-9v=" + aes.decrypt(bytes.fromhex(c)).hex()
+    logger.debug("cookie = " + cookie)
     support.config.set_setting('cookie', cookie, __channel__)
     headers = [['Cookie', cookie]]
 
 
-def get_data(item):
-    # support.dbg()
-    # url = support.match(item.url, headers=headers, follow_redirects=True, only_headers=True).url
-    data = support.match(item.url, headers=headers, follow_redirects=True).data
-    if 'ASCookie' in data:
+def get_data(url):
+    data = support.match(url, headers=headers, follow_redirects=True).data
+    if 'ASNew-9v' in data:
         get_cookie(data)
-        data = get_data(item)
+        data = get_data(url)
     return data
 
 
 @support.menu
 def mainlist(item):
 
-    anime = ['/animelist?load_all=1&d=1',
+    anime = ['/animelist',
              ('ITA',['', 'submenu', '/filter?language%5B0%5D=1']),
              ('SUB-ITA',['', 'submenu', '/filter?language%5B0%5D=0']),
              ('Più Votati',['/toplist','menu', 'top']),
@@ -78,7 +83,7 @@ def newest(categoria):
 
 @support.scrape
 def submenu(item):
-    data = support.match(item.url + item.args).data
+    data = get_data(item.url + item.args) #support.match(item.url + item.args).data
     action = 'filter'
     patronMenu = r'<h5 class="[^"]+">(?P<title>[^<]+)[^>]+>[^>]+>\s*<select id="(?P<parameter>[^"]+)"[^>]+>(?P<data>.*?)</select>'
     def itemlistHook(itemlist):
@@ -89,7 +94,8 @@ def submenu(item):
 
 def filter(item):
     itemlist = []
-    matches = support.match(item.data if item.data else item.url, patron=r'<option value="(?P<value>[^"]+)"[^>]*>(?P<title>[^<]+)').matches
+    data = item.data if item.data else get_data(item.url)
+    matches = support.match(data, patron=r'<option value="(?P<value>[^"]+)"[^>]*>(?P<title>[^<]+)',  headers=headers).matches
     for value, title in matches:
         itemlist.append(item.clone(title= support.typo(title,'bold'), url='{}{}&{}%5B0%5D={}'.format(host, item.args, item.parameter, value), action='peliculas', args='filter'))
     support.thumb(itemlist, genre=True)
@@ -98,12 +104,9 @@ def filter(item):
 
 @support.scrape
 def menu(item):
-    patronMenu = r'<div class="col-md-13 bg-dark-as-box-shadow p-2 text-white text-center">(?P<title>[^"<]+)<(?P<other>.*?)(?:"lista-top"|"clearfix")'
-    action = 'peliculas'
-    item.args = 'top'
-    def itemHook(item2):
-        item2.url = item.url
-        return item2
+    data = item.data if item.data else get_data(item.url)
+    patronMenu = r'<div class="col-md-9 pl-0 mobile-padding margin-top-anime-page float-left pr-0">.*?href="(?P<url>[^"]+)".*?</div>(?P<title>.*?)<'
+    action = 'check'
 
     return locals()
 
@@ -116,9 +119,7 @@ def peliculas(item):
     action = 'check'
     page = None
     post = "page=" + str(item.page if item.page else 1) if item.page and int(item.page) > 1 else None
-    data = get_data(item)
-
-    # debug = True
+    data = get_data(item.url)
 
     if item.args == 'top':
         data = item.other
@@ -145,7 +146,7 @@ def peliculas(item):
                 return itemlist
 
         else:
-            pagination = ''
+            # pagination = ''
             if item.args == 'incorso':
                 patron = r'<a href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<(]+)(?:\s*\((?P<year>\d+)\))?(?:\s*\((?P<lang>[A-za-z-]+)\))?</a>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*<img width="[^"]+" height="[^"]+" src="(?P<thumb>[^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<plot>[^<]+)<'
             else:
@@ -156,7 +157,7 @@ def peliculas(item):
 
 
 def check(item):
-    movie = support.match(item, patron=r'Episodi:</b> (\d*) Movie')
+    movie = support.match(item, patron=r'Episodi:</b> (\d*) Movie',  headers=headers)
     if movie.match:
         episodes = episodios(item)
         if len(episodes) > 0:
@@ -170,7 +171,7 @@ def check(item):
 @support.scrape
 def episodios(item):
     if item.contentType != 'movie': anime = True
-    patron = r'episodi-link-button">\s*<a href="(?P<url>[^"]+)"[^>]+>\s*(?P<title>[^<]+)</a>'
+    patron = r'episodi-link-button">\s*<a href="(?P<url>[^"]+)"[^>]+>\s*(?P<title>[^\d<]+(?P<episode>\d+))\s*</a>'
     return locals()
 
 
@@ -178,46 +179,11 @@ def findvideos(item):
     support.info()
     itemlist = []
     links = []
-    # page_data = ''
-    # titles =['Primario', 'Secondario', 'Alternativo Primario', 'Alternativo Secondario']
-    # pre_data = support.match(item, headers=headers).data
-    # url = support.match(pre_data , patron=r'<a href="([^"]+)">[^>]+>[^>]+>G').match
-    # urls = [url, url+'&extra=1', url+'&s=alt', url+'&s=alt&extra=1']
-    # links = []
-    # support.dbg()
-    # for i, url in enumerate(urls):
-    #     data = support.match(url, headers=headers).data
-    #     if not '&s' in url:
-    #         link = support.match(data, patron=r'(?:<source type="[^"]+"\s*src=|file:\s*)"([^"]+)"', headers=headers).match
-    #     else:
-    #         link = support.match(data, headers=headers, patron=r'file:\s*"([^"]+)"').match
-    #     if not link:
-    #         page_data += data
-    #     if link and link not in links:
-    #         links.append(link)
-    #         # link += '|Referer=' + item.url
-    #         itemlist.append(item.clone(action="play", title=titles[i], url=link, server='directo'))
 
-    # return support.server(item, data=data, itemlist=itemlist)
-    main_url = support.match(item, patron=r'<a href="([^"]+)">[^>]+>[^>]+>G').match
-    # internal = support.match(data, patron=r'<a href="([^"]+)">[^>]+>[^>]+>G').match
+    main_url = support.match(item, patron=r'<a href="([^"]+)">[^>]+>[^>]+>G',  headers=headers).match
     urls = support.match(support.match(main_url, headers=headers).data, patron=r'<a class="dropdown-item"\s*href="([^"]+)', headers=headers).matches
     itemlist.append(item.clone(action="play", title='Primario', url=main_url, server='directo'))
-    itemlist.append(item.clone(action="play", title='Secondario', url=main_url + '&s=alt', server='directo'))
-    # support.dbg()
-    # for i, url in enumerate(internal_urls):
-    #     internal_data = support.match(url, headers=headers).data
-    #     if not '&s' in url:
-    #         link = support.match(internal_data, patron=r'(?:<source type="[^"]+"\s*src=|file:\s*)"([^"]+)"', headers=headers).match
-    #     else:
-    #         link = support.match(internal_data, headers=headers, patron=r'file:\s*"([^"]+)"').match
-    #     if not link:
-    #         links.append(internal_data)
-    #     if link and link not in links:
-    #         links.append(link)
-    #         itemlist.append(item.clone(action="play", title=internal_titles[i], url=link, server='directo'))
-    # link = support.match(external[0], patron=r'href="([^"]+)', headers=headers, debug=True).match
-    # support.dbg()
+    #itemlist.append(item.clone(action="play", title='Secondario', url=main_url + '&s=alt', server='directo'))
     for url in urls:
         link = support.match(url, patron=r'<a href="([^"]+)"[^>]+><button', headers=headers).match
         if link:
@@ -225,10 +191,7 @@ def findvideos(item):
     return support.server(item, data=links, itemlist=itemlist)
 
 
-
-
-
-
-
-
-
+def play(item):
+    if item.server == 'directo':
+        item.url = support.match(item.url, patron=r'(?:source type="[^"]+"\s*src=|file:[^"]+)"([^"]+)',  headers=headers).match
+    return[item]

channels/animeunity.py

@@ -4,17 +4,13 @@
 # ------------------------------------------------------------
 
 import cloudscraper, json, copy, inspect
-from core import jsontools, support, httptools, filetools
-from platformcode import autorenumber, logger
-import re
-import xbmc
-
-
-session = cloudscraper.create_scraper()
+from core import jsontools, support, httptools, scrapertools
+from platformcode import autorenumber
 
+# support.dbg()
 host = support.config.get_channel_url()
-response = session.get(host + '/archivio')
-csrf_token = support.match(response.text, patron='name="csrf-token" content="([^"]+)"').match
+response = httptools.downloadpage(host + '/archivio')
+csrf_token = support.match(response.data, patron='name="csrf-token" content="([^"]+)"').match
 headers = {'content-type': 'application/json;charset=UTF-8',
            'x-csrf-token': csrf_token,
            'Cookie' : '; '.join([x.name + '=' + x.value for x in response.cookies])}
@@ -57,7 +53,7 @@ def genres(item):
     # support.dbg()
     itemlist = []
 
-    genres = json.loads(support.match(response.text, patron='genres="([^"]+)').match.replace('"','"'))
+    genres = json.loads(support.match(response.data, patron='genres="([^"]+)').match.replace('"','"'))
 
     for genre in genres:
         item.args['genres'] = [genre]
@@ -69,10 +65,10 @@ def years(item):
     itemlist = []
 
     from datetime import datetime
-    current_year = datetime.today().year
-    oldest_year = int(support.match(response.text, patron='anime_oldest_date="([^"]+)').match)
+    next_year = datetime.today().year + 1
+    oldest_year = int(support.match(response.data, patron='anime_oldest_date="([^"]+)').match)
 
-    for year in list(reversed(range(oldest_year, current_year + 1))):
+    for year in list(reversed(range(oldest_year, next_year + 1))):
         item.args['year']=year
         itemlist.append(item.clone(title=support.typo(year,'bold'), action='peliculas'))
     return itemlist
@@ -120,19 +116,31 @@ def news(item):
     support.info()
     item.contentType = 'episode'
     itemlist = []
-    import cloudscraper
-    session = cloudscraper.create_scraper()
 
-    fullJs = json.loads(support.match(session.get(item.url).text, headers=headers, patron=r'items-json="([^"]+)"').match.replace('"','"'))
+    fullJs = json.loads(support.match(httptools.downloadpage(item.url).data, headers=headers, patron=r'items-json="([^"]+)"').match.replace('"','"'))
     js = fullJs['data']
 
     for it in js:
+        if it.get('anime', {}).get('title') or it.get('anime', {}).get('title_eng'):
+            title_name = it['anime']['title'] if it.get('anime', {}).get('title') else it['anime']['title_eng']
+            pattern = r'[sS](?P<season>\d+)[eE](?P<episode>\d+)'
+            match = scrapertools.find_single_match(it['file_name'], pattern)
+            full_episode = ''
+            if match:
+                season, episode = match
+                full_episode = ' - S' + season + ' E' + episode
+            else:
+                pattern = r'[._\s]Ep[._\s]*(?P<episode>\d+)'
+                episode = scrapertools.find_single_match(it['file_name'], pattern)
+                if episode:
+                    full_episode = ' - E' + episode                             
             itemlist.append(
-            item.clone(title= support.typo(it['anime']['title'] + ' - EP. ' + it['number'], 'bold'),
+                item.clone(title = support.typo(title_name + full_episode, 'bold'),
                            fulltitle = it['anime']['title'],
                            thumbnail = it['anime']['imageurl'],
                            forcethumb = True,
-                       video_url=it['scws_id'],
+                           scws_id = it.get('scws_id', ''),
+                           url = '{}/anime/{}-{}'.format(item.url, it['anime']['id'],it['anime']['slug']),
                            plot = it['anime']['plot'],
                            action = 'findvideos')
             )
@@ -154,37 +162,42 @@ def peliculas(item):
         item.args['order'] = order_list[order]
 
     payload = json.dumps(item.args)
-    records = session.post(host + '/archivio/get-animes', headers=headers, data=payload).json()['records']
+    records = httptools.downloadpage(host + '/archivio/get-animes', headers=headers, post=payload).json['records']
+    # support.dbg()
 
     for it in records:
-        logger.debug(jsontools.dump(it))
+        if not it['title']:
+            it['title'] = ''
         lang = support.match(it['title'], patron=r'\(([It][Tt][Aa])\)').match
         title = support.re.sub(r'\s*\([^\)]+\)', '', it['title'])
 
         if 'ita' in lang.lower(): language = 'ITA'
         else: language = 'Sub-ITA'
 
+        if title:
             itm = item.clone(title=support.typo(title,'bold') + support.typo(language,'_ [] color kod') + (support.typo(it['title_eng'],'_ ()') if it['title_eng'] else ''))
+        else:
+            itm = item.clone(title=support.typo(it['title_eng'],'bold') + support.typo(language,'_ [] color kod'))
         itm.contentLanguage = language
         itm.type = it['type']
         itm.thumbnail = it['imageurl']
         itm.plot = it['plot']
-        itm.url = item.url
+        itm.url = '{}/anime/{}-{}'.format(item.url, it.get('id'), it.get('slug'))
 
         if it['episodes_count'] == 1:
             itm.contentType = 'movie'
             itm.fulltitle = itm.show = itm.contentTitle = title
             itm.contentSerieName = ''
             itm.action = 'findvideos'
-            itm.video_url = it['episodes'][0]['scws_id']
+            itm.scws_id = it['episodes'][0].get('scws_id', '')
+            # itm.video_url = it['episodes'][0].get('link', '')
 
         else:
             itm.contentType = 'tvshow'
             itm.contentTitle = ''
             itm.fulltitle = itm.show = itm.contentSerieName = title
             itm.action = 'episodios'
-            itm.episodes = it['episodes'] if 'episodes' in it else it['scws_id']
-            itm.video_url = item.url
+            itm.episodes = it['episodes'] if 'episodes' in it else it.get('scws_id', '')
 
         itemlist.append(itm)
 
@@ -200,7 +213,7 @@ def episodios(item):
     title = 'Parte' if item.type.lower() == 'movie' else 'Episodio'
     for it in item.episodes:
         itemlist.append(
-            item.clone(title=support.typo(title + it['number'], 'bold'),
+            item.clone(title=support.typo('{}. {} {}'.format(it['number'], title, it['number']), 'bold'),
                        episode = it['number'],
                        fulltitle=item.title,
                        show=item.title,
@@ -210,9 +223,12 @@ def episodios(item):
                        plot=item.plot,
                        action='findvideos',
                        contentType='episode',
-                       video_url=it['scws_id']))
+                       url = '{}/{}'.format(item.url, it['id'])
+                      )
+                    #    video_url=it.get('link', ''))
+            )
 
-    if inspect.stack()[1][3] not in ['find_episodes']:
+    if inspect.stack(0)[1][3] not in ['find_episodes']:
         autorenumber.start(itemlist, item)
     support.videolibrary(itemlist, item)
     support.download(itemlist, item)
@@ -220,67 +236,33 @@ def episodios(item):
 
 
 def findvideos(item):
-    # def calculateToken():
+    # if item.scws_id:
     #     from time import time
-    #     from base64 import b64encode as b64
-    #     import hashlib
-    #     o = 48
-    #     n = support.match('https://au-1.scws-content.net/get-ip').data
-    #     i = 'Yc8U6r8KjAKAepEA'
-    #     t = int(time() + (3600 * o))
-    #     l = '{}{} {}'.format(t, n, i)
-    #     md5 = hashlib.md5(l.encode())
-    #     s = '?token={}&expires={}'.format(b64(md5.digest()).decode().replace('=', '').replace('+', "-").replace('\\', "_"), t)
-    #     return s
-    # token = calculateToken()
-
-    # url = 'https://streamingcommunityws.com/master/{}{}'.format(item.video_url, token)
-
-    # # support.dbg()
-
-    # m3u8_original = httptools.downloadpage(url, CF=False).data
-
-    # m_video = re.search(r'\.\/video\/(\d+p)\/playlist.m3u8', m3u8_original)
-    # video_res = m_video.group(1)
-    # m_audio = re.search(r'\.\/audio\/(\d+k)\/playlist.m3u8', m3u8_original)
-    # audio_res = m_audio.group(1)
-
-    # # https://streamingcommunityws.com/master/5957?type=video&rendition=480p&token=wQLowWskEnbLfOfXXWWPGA&expires=1623437317
-    # video_url = 'https://streamingcommunityws.com/master/{}{}&type=video&rendition={}'.format(item.video_url, token, video_res)
-    # audio_url = 'https://streamingcommunityws.com/master/{}{}&type=audio&rendition={}'.format(item.video_url, token, audio_res)
-
-    # m3u8_original = m3u8_original.replace( m_video.group(0),  video_url )
-    # m3u8_original = m3u8_original.replace( m_audio.group(0),  audio_url )
-
-    # file_path = 'special://temp/animeunity.m3u8'
-
-    # filetools.write(xbmc.translatePath(file_path), m3u8_original, 'w')
-
-    # return support.server(item, itemlist=[item.clone(title=support.config.get_localized_string(30137), url=file_path, manifest = 'hls', server='directo', action='play')])
-    # item.url=item.video_url
-
-    directLink = False
-    if item.video_url == None:
-        if item.extra == "tvshow":
-            epnum = item.episode
-            logger.info('it is a episode', epnum)
-            episode = None
-            for ep in item.episodes:
-                if ep["number"] == epnum:
-                    episode = ep
-                    break
-            if episode == None:
-                logger.warn('cannot found episode')
-            else:
-                item.url = episode["link"]
-                directLink = True
-
-    if directLink:
-        logger.info('try direct link')
-        return support.server(item, itemlist=[item.clone(title=support.config.get_localized_string(30137), url=item.url, server='directo', action='play')])
-    else:
-        return support.server(item, itemlist=[item.clone(title="StreamingCommunityWS", url=str(item.video_url), manifest = 'hls', server='streamingcommunityws', action='play')])
-
+    #     from base64 import b64encode
+    #     from hashlib import md5
+    #
+    #     client_ip = support.httptools.downloadpage('http://ip-api.com/json/').json.get('query')
+    #
+    #     expires = int(time() + 172800)
+    #     token = b64encode(md5('{}{} Yc8U6r8KjAKAepEA'.format(expires, client_ip).encode('utf-8')).digest()).decode('utf-8').replace('=', '').replace('+', '-').replace('/', '_')
+    #
+    #     url = 'https://scws.work/master/{}?token={}&expires={}&n=1'.format(item.scws_id, token, expires)
+    #
+    #     itemlist = [item.clone(title=support.config.get_localized_string(30137), url=url, server='directo', action='play')]
 
+    from core import channeltools
+    itemlist = [item.clone(title=channeltools.get_channel_parameters(item.channel)['title'],
+                           url=item.url, server='streamingcommunityws')]
+    return support.server(item, itemlist=itemlist, referer=False)
 
+    # return support.server(item, itemlist=itemlist)
 
+#
+# def play(item):
+#     urls = list()
+#     info = support.match(item.url, patron=r'(http.*?rendition=(\d+)[^\s]+)').matches
+#
+#     if info:
+#         for url, res in info:
+#             urls.append(['hls [{}]'.format(res), url])
+#     return urls

channels/animeuniverse.json

@@ -1,7 +1,7 @@
 {
     "id": "animeuniverse",
-    "name": "AnimeUniverse",
-    "active": true,
+    "name": "AnimeHDitalia",
+    "active": false,
     "language": ["ita", "sub-ita"],
     "thumbnail": "animeuniverse.png",
     "banner": "animeuniverse.png",

channels/animeuniverse.py

@@ -10,7 +10,7 @@ headers = {}
 
 perpage_list = ['20','30','40','50','60','70','80','90','100']
 perpage = perpage_list[support.config.get_setting('perpage' , 'animeuniverse')]
-epPatron = r'<td>\s*(?P<title>[^<]+)[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)"'
+epPatron = r'<td>\s*(?P<title>[^<]+)[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>\s*<img [^>]+Streaming'
 
 
 @support.menu
@@ -103,6 +103,7 @@ def episodios(item):
     anime = True
     pagination = int(perpage)
     patron = epPatron
+    # debug = True
     return locals()
 
 

channels/animeworld.json

@@ -7,6 +7,15 @@
     "banner": "animeworld.png",
     "categories": ["anime", "vos"],
     "settings": [
+        {
+            "id": "lang",
+            "type": "list",
+            "label": "Lingua di Ricerca",
+            "default": 0,
+            "enabled": true,
+            "visible": true,
+            "lvalues": [ "Tutte", "Ita", "Sub-Ita"]
+        },
         {
             "id": "order",
             "type": "list",

channels/animeworld.py

@@ -4,7 +4,7 @@
 # thanks to fatshotty
 # ----------------------------------------------------------
 
-from core import httptools, support, jsontools
+from core import httptools, support, config, jsontools
 
 host = support.config.get_channel_url()
 __channel__ = 'animeworld'
@@ -23,7 +23,7 @@ def get_data(item):
     # support.dbg()
     url = httptools.downloadpage(item.url, headers=headers, follow_redirects=True, only_headers=True).url
     data = support.match(url, headers=headers, follow_redirects=True).data
-    if 'AWCookieVerify' in data:
+    if 'SecurityAW' in data:
         get_cookie(data)
         data = get_data(item)
     return data
@@ -37,8 +37,8 @@ def order():
 @support.menu
 def mainlist(item):
     anime=['/filter?sort=',
-           ('ITA',['/filter?dub=1&sort=', 'menu', '1']),
-           ('SUB-ITA',['/filter?dub=0&sort=', 'menu', '0']),
+           ('ITA',['/filter?dub=1&sort=', 'menu', 'dub=1']),
+           ('SUB-ITA',['/filter?dub=0&sort=', 'menu', 'dub=0']),
            ('In Corso', ['/ongoing', 'peliculas','noorder']),
            ('Ultimi Episodi', ['/updated', 'peliculas', 'updated']),
            ('Nuove Aggiunte',['/newest', 'peliculas','noorder' ]),
@@ -50,6 +50,7 @@ def mainlist(item):
 def genres(item):
     action = 'peliculas'
     data = get_data(item)
+
     patronBlock = r'dropdown[^>]*>\s*Generi\s*<span.[^>]+>(?P<block>.*?)</ul>'
     patronMenu = r'<input.*?name="(?P<name>[^"]+)" value="(?P<value>[^"]+)"\s*>[^>]+>(?P<title>[^<]+)</label>'
 
@@ -75,9 +76,10 @@ def menu(item):
 def submenu(item):
     action = 'peliculas'
     data = item.other
+    # debug=True
     patronMenu = r'<input.*?name="(?P<name>[^"]+)" value="(?P<value>[^"]+)"\s*>[^>]+>(?P<title>[^<]+)<\/label>'
     def itemHook(item):
-        item.url = host + '/filter?' + item.name + '=' + item.value + '&dub=' + item.args + ('&sort=' if item.name != 'sort' else '')
+        item.url = '{}/filter?{}={}&{}{}'.format(host, item.name, item.value, item.args, ('&sort=' if item.name != 'sort' else ''))
         return item
     return locals()
 
@@ -85,9 +87,10 @@ def submenu(item):
 def newest(categoria):
     support.info(categoria)
     item = support.Item()
+    lang = config.get_setting('lang', channel=item.channel)
     try:
         if categoria == "anime":
-            item.url = host + '/updated'
+            item.url = host
             item.args = "updated"
             return peliculas(item)
     # Continua la ricerca in caso di errore
@@ -98,13 +101,13 @@ def newest(categoria):
         return []
 
 
-def search(item, texto):
-    support.info(texto)
+def search(item, text):
+    support.info(text)
     if item.search:
-        item.url = host + '/filter?dub=' + item.args + '&keyword=' + texto + '&sort='
+        item.url = '{}/filter?{}&keyword={}&sort='.format(host, item.args, text)
     else:
-        item.args = 'noorder'
-        item.url = host + '/search?keyword=' + texto
+        lang = ['?', '?dub=1&', '?dub=0&'][config.get_setting('lang', channel=item.channel)]
+        item.url = '{}/filter{}&keyword={}&sort='.format(host, lang, text)
     item.contentType = 'tvshow'
     try:
         return peliculas(item)
@@ -118,14 +121,14 @@ def search(item, texto):
 
 @support.scrape
 def peliculas(item):
+    data = get_data(item)
     anime = True
-    # debug = True
     if item.args not in ['noorder', 'updated'] and not item.url[-1].isdigit(): item.url += order() # usa l'ordinamento di configura canale
     data = get_data(item)
 
     if item.args == 'updated':
         item.contentType='episode'
-        patron=r'<div class="inner">\s*<a href="(?P<url>[^"]+)" class[^>]+>\s*<img.*?src="(?P<thumb>[^"]+)" alt?="(?P<title>[^\("]+)(?:\((?P<lang>[^\)]+)\))?"[^>]+>[^>]+>\s*(?:<div class="[^"]+">(?P<type>[^<]+)</div>)?[^>]+>[^>]+>\s*<div class="ep">[^\d]+(?P<episode>\d+)[^<]*</div>'
+        patron=r'<div class="inner">\s*<a href="(?P<url>[^"]+)" class[^>]+>\s*<img.*?src="(?P<thumb>[^"]+)" alt?="(?P<title>[^\("]+)(?:\((?P<lang>[^\)]+)\))?"[^>]+>[^>]+>\s*(?:<div class="[^"]+">(?P<type>[^<]+)</div>)?(?:[^>]+>){2,4}\s*<div class="ep">[^\d]+(?P<episode>\d+)[^<]*</div>'
         action='findvideos'
     else:
         patron= r'<div class="inner">\s*<a href="(?P<url>[^"]+)" class[^>]+>\s*<img.*?src="(?P<thumb>[^"]+)" alt?="(?P<title>[^\("]+)(?:\((?P<year>\d+)\) )?(?:\((?P<lang>[^\)]+)\))?(?P<title2>[^"]+)?[^>]+>[^>]+>(?:\s*<div class="(?P<l>[^"]+)">[^>]+>)?\s*(?:<div class="[^"]+">(?P<type>[^<]+)</div>)?'
@@ -185,7 +188,9 @@ def findvideos(item):
             else:
                 dataJson = support.match(host + '/api/episode/info?id=' + epID + '&alt=0', headers=headers).data
                 json = jsontools.load(dataJson)
+
                 title = support.match(json['grabber'], patron=r'server\d+.([^.]+)', string=True).match
                 if title: itemlist.append(item.clone(action="play", title=title, url=json['grabber'].split('=')[-1], server='directo'))
                 else: urls.append(json['grabber'])
+    # support.info(urls)
     return support.server(item, urls, itemlist)

channels/aniplay.json

@@ -1,7 +1,7 @@
 {
     "id": "aniplay",
     "name": "AniPlay",
-    "active": true,
+    "active": false,
     "language": ["ita", "sub-ita"],
     "thumbnail": "aniplay.png",
     "banner": "aniplay.png",

channels/aniplay.py

@@ -1,5 +1,5 @@
 from platformcode import config, logger, autorenumber
-from core import httptools, scrapertools, support, tmdb
+from core import httptools, scrapertools, support, tmdb, jsontools
 from inspect import stack
 
 import sys
@@ -34,6 +34,7 @@ def submenu_az(item):
                                 thumbnail=support.thumb('az')))
     return itemlist
 
+
 def submenu_year(item):
     itemlist = []
     from datetime import date
@@ -46,6 +47,7 @@ def submenu_year(item):
                                 thumbnail=support.thumb('year')))
     return itemlist
 
+
 def submenu_top(item):
     itemlist = []
     links = {'Top del giorno':'daily-top', 'Top della settimana':'weekly-top', 'Top del mese':'monthly-top'}
@@ -56,6 +58,7 @@ def submenu_top(item):
                                 variable= link))
     return itemlist
 
+
 def submenu_season(item):
     itemlist = []
     seasons = {'winter':'Inverno', 'spring':'Primavera', 'summer':'Estate', 'fall':'Autunno'}
@@ -71,6 +74,7 @@ def submenu_season(item):
                                    variable=''))
     return itemlist
 
+
 def submenu_top_of(item):
     itemlist = []
     url= '{}/api/home/{}'.format(host, item.variable)
@@ -83,15 +87,14 @@ def submenu_top_of(item):
         long_title = support.typo(title, 'bold') + support.typo(lang, '_ [] color kod')
 
         itemlist.append(item.clone(title=long_title,
-                                id=anime['animeId'],
-                                url = '{}/api/anime/{}'.format(host, anime['animeId']),
+                                   url = '{}/anime/{}'.format(host, anime['animeId']),
+                                   video_url = '{}/api/anime/{}'.format(host, anime['animeId']),
                                    thumbnail = get_thumbnail(anime, 'animeHorizontalImages'),
                                    action = 'episodios',
                                    variable=anime['animeId']))
     return itemlist
 
 
-
 def search(item, texto):
     support.info(texto)
     item.url = host + '/api/anime/advanced-search'
@@ -128,7 +131,7 @@ def latest_added(item):
     js = httptools.downloadpage(url).json
 
     for episode in js:
-        title = episode['title']
+        title = episode['title'] if episode['title'] else ''
         animeTitle, lang =  get_lang(episode['animeTitle'])
         quality = 'Full HD' if episode['fullHd'] else 'HD'
         long_title = support.typo('{}. {}{}'.format(int(float(episode['episodeNumber'])), title + ' - ' if title else '', animeTitle), 'bold') + support.typo(lang, '_ [] color kod') + support.typo(quality, '_ [] color kod')
@@ -136,15 +139,14 @@ def latest_added(item):
 
         itemlist.append(item.clone(title=long_title,
                                    fulltitle=title,
-                                   animeId = episode['animeId'],
-                                   id=episode['id'],
+                                   url='{}/play/{}'.format(host, episode['id']),
                                    contentType = 'episode',
                                    contentTitle = title,
                                    contentSerieName = animeTitle,
                                    contentLanguage = lang,
                                    quality = quality,
                                    contentEpisodeNumber = int(float(episode['episodeNumber'])),
-                                   animeUrl = '{}/api/anime/{}'.format(host, episode['animeId']),
+                                   video_url = '{}/api/episode/{}'.format(host, episode['id']),
                                    thumbnail = image,
                                    fanart = image,
                                    action = 'findvideos'))
@@ -163,6 +165,7 @@ def peliculas(item):
     js = httptools.downloadpage('{}?page={}&size={}{}&sort={},{}&sort=id'.format(item.url, page, perpage, item.variable, sort, order)).json
 
     for it in js:
+        logger.debug(jsontools.dump(js))
         title, lang = get_lang(it['title'])
 
         long_title = support.typo(title, 'bold') + support.typo(lang, '_ [] color kod')
@@ -174,10 +177,10 @@ def peliculas(item):
                                    contentType = 'movie' if it['type'] == 'Movie' else 'tvshow',
                                    contentTitle = title,
                                    contentSerieName = title if it['type'] == 'Serie' else '',
-                                   action ='findvideos' if it['type'] == 'Movie' else 'episodios',# '' if not active else 'findvideos' if it['type'] == 'Movie' else 'episodios',
+                                   action ='findvideos' if it['type'] == 'Movie' else 'episodios',
                                    plot = it['storyline'],
-                                   year = it['startDate'].split('-')[0],
-                                   url = '{}/api/anime/{}'.format(host, it['id']),
+                                   url = '{}/anime/{}'.format(host, it['id']),
+                                   video_url = '{}/api/anime/{}'.format(host, it.get('animeId', it.get('id'))),
                                    thumbnail = get_thumbnail(it),
                                    fanart = get_thumbnail(it, 'horizontalImages')))
 
@@ -192,9 +195,10 @@ def peliculas(item):
 def episodios(item):
     logger.debug()
     itemlist = []
-
+    if not item.video_url:
+        item.video_url = item.url.replace('/anime/', '/api/anime/')
     # url = '{}/api/anime/{}'.format(host, item.id)
-    json = httptools.downloadpage(item.url, CF=False ).json
+    json = httptools.downloadpage(item.video_url, CF=False ).json
 
     if type(json) == list:
         item.show_renumber = False
@@ -208,7 +212,7 @@ def episodios(item):
             title = it['name']
 
             itemlist.append(item.clone(title = title,
-                                       id= '{}/season/{}'.format(it['animeId'], it['id']),
+                                       video_url = '{}/api/anime/{}/season/{}'.format(host, it['animeId'], it['id']),
                                        contentType = 'season',
                                        action = 'list_episodes',
                                        plot = json['storyline'],
@@ -245,8 +249,7 @@ def list_episodes(item, json=None):
     itemlist = []
 
     if not json:
-        url = '{}/api/anime/{}'.format(host, item.id)
-        json = httptools.downloadpage(url, CF=False ).json
+        json = httptools.downloadpage(item.video_url, CF=False ).json
 
     episodes = json['episodes'] if 'episodes' in json else json
     episodes.sort(key=lambda ep: int(ep['episodeNumber'].split('.')[0]))
@@ -263,8 +266,8 @@ def list_episodes(item, json=None):
         image = get_thumbnail(it, 'episodeImages')
 
         itemlist.append(item.clone(title = title,
-                                   id= it['id'],
-                                   url= 'api/episode/{}'.format(it['id']),
+                                   url= '{}/play/{}'.format(host, it['id']),
+                                   video_url= '{}/api/episode/{}'.format(host, it['id']),
                                    contentType = 'episode',
                                    contentEpisodeNumber = int(it['episodeNumber'].split('.')[0]),
                                    contentSeason = item.contentSeason if item.contentSeason else '',
@@ -283,20 +286,18 @@ def list_episodes(item, json=None):
 def findvideos(item):
     logger.debug()
 
-    url = '{}/api/{}/{}'.format(host, 'episode' if item.contentType == 'episode' else 'anime', item.id)
+    res = httptools.downloadpage(item.video_url, CF=False ).json
 
-    json = httptools.downloadpage(url, CF=False ).json
+    if res.get('episodes', []):
+        res = httptools.downloadpage('{}/api/episode/{}'.format(host, res['episodes'][0]['id'])).json
 
-    if json.get('episodes', []):
-        json = httptools.downloadpage('{}/api/episode/{}'.format(host, json['episodes'][0]['id'])).json
+    item.url = res['videoUrl']
+    item.server = 'directo'
 
-    videourl = json['episodeVideo']
+    if '.m3u' in item.url:
+        item.manifest = 'hls'
 
-    itemlist = [item.clone(title=config.get_localized_string(30137),
-                           url=videourl,
-                           server='directo')]
-
-    return support.server(item, itemlist=itemlist)
+    return support.server(item, itemlist=[item])
 
 
 def get_thumbnail(data, prop = 'verticalImages', key = 'full'):

channels/bt4g.json

@@ -0,0 +1,12 @@
+{
+    "id": "bt4g",
+    "name": "BT4G",
+    "active": false,
+    "language": ["ita", "sub-ita", "eng"],
+    "thumbnail": "bt4g.png",
+    "banner": "bt4g.png",
+    "categories": ["movie", "tvshow", "torrent"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+	"settings": []
+}

channels/bt4g.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per ilcorsaronero
+# ------------------------------------------------------------
+
+from core import support, httptools
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+
+    search = ''
+    return locals()
+
+@support.scrape
+def peliculas(item):
+    debug = False
+    action = 'findvideos'
+    sceneTitle = True
+
+    def itemHook(item):
+        item.title = support.scrapertools.decodeHtmlentities(support.urlparse.unquote(item.title))
+
+        return item
+
+    if not item.nextpage:
+        item.page = 1
+    else:
+        item.page = item.nextpage
+
+    if not item.parent_url:
+        item.parent_url = item.url
+
+    item.nextpage = item.page + 1
+    nextPageUrl = "{}/search?{}".format(host, support.urlencode({'q': item.args,'category': 'movie', 'page': 'rss', 'orderby' : 'seeders', 'p' : item.nextpage}))
+    resp = httptools.downloadpage(nextPageUrl)
+    if ('item' not in resp.data.lower()): # no more elements
+        nextPageUrl = ''
+
+    patron = r'<item>.*?<title>(?P<title>.*?)</title><link>(?P<url>.*?)</link>'
+    return locals()
+
+def search(item, text):
+    item.url = "{}/search?{}".format(host, support.urlencode({'q': text,'category': 'movie', 'page': 'rss', 'orderby' : 'seeders'}))
+    item.args = text
+
+    try:
+        return peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("search except: %s" % line)
+        return []
+
+def findvideos(item):
+    return support.server(item, item.url)

channels/casacinema.json

@@ -5,7 +5,8 @@
     "active": true,
     "thumbnail": "casacinema.png",
     "banner": "casacinema.png",
-    "categories": ["tvshow", "movie","vos"],
+    "categories": ["tvshow", "movie"],
+    "not_active": ["include_in_newest"],
     "settings": [
     ]
 }

channels/casacinema.py

@@ -4,7 +4,8 @@
 # ------------------------------------------------------------
 
 
-from core import support
+from core import support,httptools
+from platformcode import logger
 
 host = support.config.get_channel_url()
 headers = [['Referer', host]]
@@ -12,14 +13,12 @@ headers = [['Referer', host]]
 
 @support.menu
 def mainlist(item):
-    film = ['/category/film',
-        ('Generi', ['', 'genres', 'genres']),
-        ('Sub-ITA', ['/category/sub-ita/', 'peliculas', 'sub'])
-        ]
 
-    tvshow = ['/category/serie-tv',
-        ('Novità', ['/aggiornamenti-serie-tv', 'peliculas', '']),
-        ]
+    top = [('Generi', ['', 'genres'])]
+    film = ['/film']
+
+    tvshow = ['/serie-tv', 
+          ('Miniserie ', ['/miniserie-tv', 'peliculas', ''])]    
 
     search = ''
 
@@ -29,88 +28,39 @@ def mainlist(item):
 @support.scrape
 def genres(item):
     action = 'peliculas'
-    blacklist = ['PRIME VISIONI', 'ULTIME SERIE TV', 'ULTIMI FILM']
+    blacklist = ['Serie TV', 'Miniserie TV']
     patronMenu = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<>]+)</a></li>'
-    patronBlock = r'<div class="container home-cats">(?P<block>.*?)<div class="clear">'
+    patronBlock = r'<a href="#">Categorie</a>(?P<block>.*?)<a href="#"'
     return locals()
 
 
-def select(item):
-    item.data = support.match(item).data
-    if 'continua con il video' in item.data.lower():
-        support.info('select = ### è un film ###')
-        item.contentType = 'movie'
-        return findvideos(item)
-    else:
-        support.info('select = ### è una serie ###')
+def check(item):
+    item.data = httptools.downloadpage(item.url).data
+    if 'stagione' in item.data.lower():
         item.contentType = 'tvshow'
         return episodios(item)
+    else:
+        return findvideos(item)
 
 
 def search(item, text):    
-    support.info(text)
-    text = text.replace(' ', '+')
-    item.url = host + '/?s=' + text
+    item.url = "{}/?{}".format(host, support.urlencode({'story': text,'do':'search', 'subaction':'search'}))
+    try:
         item.args = 'search'
-    try:
         return peliculas(item)
 
-    except:
-        import sys
-        for line in sys.exc_info():
-            support.info('search log:', line)
-        return []
-
-
-def newest(categoria):
-    itemlist = []
-    item = support.Item()
-    item.args = 'newest'
-
-    try:
-        if categoria == 'series':
-            item.contentType = 'tvshow'
-            item.url = host+'/aggiornamenti-serie-tv'
-
-        else:
-            item.contentType = 'movie'
-            item.url = host+'/category/film'
-
-        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():
-            support.info("%s" % line)
+            logger.error("%s" % line)
         return []
 
-    return itemlist
-
-
 @support.scrape
 def peliculas(item):
-    # debug = True
-    if item.contentType == 'movie':
-        action = 'findvideos'
-    elif item.contentType == 'tvshow':
-        action = 'episodios'
-        pagination = ''
-    else:
-        action = 'select'
-
-    if item.args == 'newest':
-        patron = r'<li><a href="(?P<url>[^"]+)"[^=]+="(?P<thumb>[^"]+)"><div>\s*?<div[^>]+>(?P<title>[^\(\[<]+)(?:\[(?P<quality1>HD)\])?[ ]?(?:\(|\[)?(?P<lang>[sS]ub-[iI][tT][aA])?(?:\)|\])?[ ]?(?:\[(?P<quality>.+?)\])?[ ]?(?:\((?P<year>\d+)\))?<(?:[^>]+>.+?(?:title="Nuovi episodi">(?P<episode>\d+x\d+)[ ]?(?P<lang2>Sub-Ita)?|title="IMDb">(?P<rating>[^<]+)))?'
-    else:
-        # patron = r'<li><a href="(?P<url>[^"]+)"[^=]+="(?P<thumb>[^"]+)"><div>\s*?<div[^>]+>(?P<title>[^\(\[<]+)(?:\[(?P<quality1>HD)\])?\s?(?:[\(\[])?(?P<lang>[sS]ub-[iI][tT][aA])?(?:[\)\]])?\s?(?:\[(?P<quality>.+?)\])?\s?(?:\((?P<year>\d+)\))?<'
-        patron = r'<li><a href="(?P<url>[^"]+)"[^=]+="(?P<thumb>[^"]+)"><div>\s*?<div[^>]+>(?P<title>[^\(\[<]+)(?P<title2>\([\D*]+\))?(?:\[(?P<quality1>HD)\])?\s?(?:[\(\[])?(?P<lang>[sS]ub-[iI][tT][aA])?(?:[\)\]])?\s?(?:\[(?P<quality>.+?)\])?\s?(?:\((?P<year>\d+)\))?(?:\(\D{2}\s\d{4}\))?<'
-
+    action = 'check'
+    patron = r'<div class="posts".*?<a href="(?P<url>[^"]+)[^>]+>[^>]+>[^>]+>(?P<title>[^\(\[<]+)(?:\[(?P<quality1>HD)\])?'
     patronNext = r'<a href="([^"]+)"\s*>Pagina'
-    # debug = True
 
     def itemHook(item):
         if item.quality1:
@@ -121,34 +71,27 @@ def peliculas(item):
             item.title += support.typo(item.lang2, '_ [] color kod')
         if item.args == 'novita':
             item.title = item.title
-        # if 'wp-content' in item.thumbnail and not item.infoLabels['year']:
-        #     item.infoLabels['year'] = item.thumbnail.split('/')[5]
+
         return item
     return locals()
 
 
 @support.scrape
 def episodios(item):
-    if item.data:
-        data = item.data
+    patron = r'data-num="(?P<season>.*?)x(?P<episode>.*?)"\s*data-title="(?P<title>[^"]+)(?P<lang>[sS][uU][bB]\-[iI][tT][aA]+)?".*?<div class="mirrors"(?P<server_links>.*?)<!---'
     action = 'findvideos'
-    item.contentType = 'tvshow'
-    blacklist = ['']
-    patron = r'(?P<episode>\d+(?:&#215;|×)?\d+\-\d+|\d+(?:&#215;|×)\d+)[;]?(?:(?P<title>[^<]+)<(?P<data>.*?)|(\2[ ])(?:<(\3.*?)))(?:<br />|</p>)'
-    patronBlock = r'<strong>(?P<block>(?:.+?Stagione*.+?(?P<lang>[Ii][Tt][Aa]|[Ss][Uu][Bb][\-]?[iI][tT][aA]))?(?:.+?|</strong>)(/?:</span>)?</p>.*?</p>)'
     return locals()
 
 
 def findvideos(item):
-    if item.contentType != 'movie':
-        links = support.match(item.data, patron=r'href="([^"]+)"').matches
-    else:
-        matchData = item.data if item.data else item
-        links = support.match(matchData, patron=r'(?:SRC|href)="([^"]+)"', patronBlock=r'<div class="col-md-10">(.+?)<div class="ads">').matches
-    data = ''
-    from lib.unshortenit import unshorten_only
-    for link in links:
-        support.info('URL=',link)
-        url, c = unshorten_only(link.replace('#', 'speedvideo.net'))
-        data += url + '\n'
-    return support.server(item, data)
+    if item.server_links:
+        return support.server(item, data = item.server_links)
+
+    video_url = support.match(item.url, patron=r'player[^>]+>[^>]+>.*?src="([^"]+)"').match
+
+    if (video_url == ''):
+       return []
+
+    itemlist = [item.clone(action="play", url=srv) for srv in support.match(video_url, patron='<li class="(?:active)?" data-link=\"([^"]+)').matches]
+    itemlist = support.server(item,itemlist=itemlist)
+    return itemlist

channels/cb01anime.json

@@ -2,7 +2,7 @@
     "id": "cb01anime",
     "name": "Cb01anime",
     "language": ["ita", "vos", "sub-ita"],
-	"active": true,
+    "active": false,
     "thumbnail": "cb01anime.png",
     "banner": "cb01anime.png",
     "categories": ["anime"],

channels/cineblog01.py

@@ -2,21 +2,20 @@
 # ------------------------------------------------------------
 # Canale per cineblog01
 # ------------------------------------------------------------
-import datetime
 import re
 
 from core import scrapertools, httptools, servertools, support
 from platformcode import logger, config
 
 
-# def findhost(url):
-#     host = httptools.downloadpage(url, follow_redirect=True).url
-#     if host == 'https://cb01.uno/':
-#         host = support.match(host, patron=r'<a href="([^"]+)').match
-#     return host
+def findhost(url):
+    host = httptools.downloadpage(url, follow_redirect=True).url
+    if host == 'https://cb01.uno/':
+        host = support.match(host, patron=r'<a href="([^"]+)').match
+    return host
 
 
-host = config.get_channel_url()
+host = config.get_channel_url(findhost)
 headers = [['Referer', host]]
 
 
@@ -24,17 +23,19 @@ headers = [['Referer', host]]
 def mainlist(item):
     film = [
         ('HD', ['', 'menu', 'Film HD Streaming']),
-        ('Generi', ['', 'menu', 'Film per Genere']),
+        ('Genere', ['', 'menu', 'Film per Genere']),
         ('Anni', ['', 'menu', 'Film per Anno']),
-        ('Paese', ['', 'menu', 'Film per Paese']),
-        ('Ultimi Aggiornati', ['/ultimi-100-film-aggiornati/', 'peliculas', 'newest']),
-        ('Ultimi Aggiunti', ['/lista-film-ultimi-100-film-aggiunti/', 'peliculas', 'newest'])
+        ('Popolari per Genere', ['', 'menu', 'Film Popolari']),
+        ('Ultimi Aggiunti', ['/ultimi-100-film-aggiunti/', 'peliculas', 'newest']),
+        ('Popolari', ['/category/film-popolari/']),
+        ('Italiani', ['/category/nazione/italia/'])
+        # ('Film in Lista', ['/lista-film/', 'peliculas', 'newest'])
     ]
     tvshow = ['/serietv/',
-              ('Per Lettera', ['/serietv/', 'menu', 'Serie-Tv per Lettera']),
-              ('Per Genere', ['/serietv/', 'menu', 'Serie-Tv per Genere']),
-              ('Per anno', ['/serietv/', 'menu', 'Serie-Tv per Anno']),
-              ('Ultime Aggiornate', ['/serietv/ultime-100-serie-tv-aggiornate/', 'peliculas', 'newest'])
+              ('Per Lettera', ['/serietv/', 'menu', 'Serie-TV x Lettera']),
+              ('Per Genere', ['/serietv/', 'menu', 'Serie-TV x Genere']),
+              ('Per anno', ['/serietv/', 'menu', 'Serie-TV x Anno']),
+              ('Ultime Aggiunte', ['/serietv/ultime-100-serie-tv-aggiunte/', 'peliculas', 'newest'])
               ]
     docu = [('Documentari {bullet bold}', ['/category/documentario/', 'peliculas']),
             ('HD {submenu} {documentari}', ['/category/hd-alta-definizione/documentario-hd/', 'peliculas'])
@@ -45,8 +46,9 @@ def mainlist(item):
 
 @support.scrape
 def menu(item):
+    # debug = True
     patronBlock = item.args + r'<span.*?><\/span>.*?<ul.*?>(?P<block>.*?)<\/ul>'
-    patronMenu = r'href="?(?P<url>[^">]+)"?>(?P<title>.*?)<\/a>'
+    patronMenu = r'href="?(?P<url>[^">]+)"?[^>]+>(?P<title>[^<»]+)'
     action = 'peliculas'
 
     return locals()
@@ -62,7 +64,7 @@ def newest(categoria):
             item.url = host + '/serietv/'  # aggiornamento-quotidiano-serie-tv/'
         else:
             item.contentType = 'movie'
-            item.url = host + '/lista-film-ultimi-100-film-aggiunti/'
+            item.url = host + '/ultimi-100-film-aggiunti/'
             item.args = "newest"
         return peliculas(item)
     # Continua la ricerca in caso di errore
@@ -104,14 +106,14 @@ def peliculas(item):
         pagination = ''
         patronBlock = r'sequex-page-left(?P<block>.*?)sequex-page-right'
         if '/serietv/' not in item.url:
-            patron = r'src="?(?P<thumb>[^ "]+)"? alt="?(?P<title>.*?)(?:\[(?P<quality>[a-zA-Z/]+)\]\s*)?(?:\[(?P<lang>Sub-ITA|ITA)\]\s*)?(?:\[(?P<quality2>[a-zA-Z/]+)\]\s*)?\((?P<year>\d{4})[^\)]*\)[^>]*>.*?<a href=(?:")?(?P<url>[^" ]+)(?:")?.*?rpwe-summary[^>]*>(?P<genre>\w+) [^ ]+ DURATA (?P<duration>[0-9]+)[^ ]+ [^ ]+ [A-Z ]+ (?P<plot>[^<]+)<'
+            patron = r'src="?(?P<thumb>[^ "]+)"? alt="?(?P<title>.*?)(?:\[(?P<quality>[a-zA-Z]+(?:[/]?3D)?)\]\s*)?(?:\[(?P<lang>Sub-ITA|ITA)\]\s*)?(?:\[(?P<quality2>[a-zA-Z]+(?:[/]?3D)?)\]\s*)?\((?P<year>\d{4})[^\)]*\)[^>]*>.*?<a href=(?:")?(?P<url>[^" ]+)(?:")?.*?rpwe-summary[^>]*>(?P<genre>\w+) [^ ]+ DURATA (?P<duration>[0-9]+)[^ ]+ [^ ]+ [A-Z ]+ (?P<plot>[^<]+)<'
             action = 'findvideos'
         else:
-            patron = r'src=(?:")?(?P<thumb>[^ "]+)(?:")? alt=(?:")?(?P<title>.*?)(?: &#8211; \d+&#215;\d+)?(?:>|"| &#8211; )(?:(?P<lang>Sub-ITA|ITA))?[^>]*>.*?<a href=(?:")?(?P<url>[^" ]+)(?:")?.*?rpwe-summary[^>]*>(?P<genre>[^\(]*)\((?P<year>\d{4})[^\)]*\) (?P<plot>[^<]+)<'
+            patron = r'src=(?:")?(?P<thumb>[^ "]+)(?:")?.*?alt=(?:")?(?P<title>.*?)(?: &#8211; \d+&#215;\d+)?(?:>|"| &#8211; )(?:(?P<lang>Sub-ITA|ITA))?[^>]*>.*?<a href=(?:")?(?P<url>[^" ]+)(?:")?.*?rpwe-summary[^>]*>(?P<genre>[^\(]*)\((?P<year>\d{4})[^\)]*\) (?P<plot>[^<]+)<'
             action = 'episodios'
 
     elif '/serietv/' not in item.url:
-        patron = r'(?<!sticky )hentry.*?<div class="card-image">\s*<a[^>]+>\s*<img src="(?P<thumb>[^" ]+)" alt[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="?(?P<url>[^" >]+)(?:\/|"|\s+)>(?P<title>[^<[(]+)(?:\[(?P<quality>[a-zA-Z/]+)\]\s*)?(?:\[(?P<lang>Sub-ITA|ITA)\]\s*)?(?:\[(?P<quality2>[a-zA-Z/]+)\]\s*)? (?:\((?P<year>[0-9]{4})\))?[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<genre>[^<>&‖“]+)(?:[^ ]+\s*DURATA\s*(?P<duration>[0-9]+)[^>]+>[^>]+>[^>]+>(?P<plot>[^<>]+))?'
+        patron = r'(?<!sticky )hentry.*?<div class="card-image">\s*<a[^>]+>\s*<img src="(?P<thumb>[^" ]+)" alt[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="?(?P<url>[^" >]+)(?:\/|"|\s+)>(?P<title>[^<[(]+)(?:\[(?P<quality>[a-zA-Z]+(?:[/]?3D)?)\]\s*)?(?:\[(?P<lang>Sub-ITA|ITA)\]\s*)?(?:\[(?P<quality2>[a-zA-Z/]+)\]\s*)? (?:\((?P<year>[0-9]{4})\))?[^>]+>[^>]+>[^>]+>[^>]+>(?P<genre>[^<>&‖“]+)(?:[^ ]+\s*DURATA\s*(?P<duration>[0-9]+)[^>]+>[^>]+>[^>]+>(?P<plot>[^<>]+))?'
         action = 'findvideos'
 
     else:
@@ -133,17 +135,17 @@ def peliculas(item):
 @support.scrape
 def episodios(item):
     @support.scrape
-    def folder(item, data):
+    def folder(item, url):
         """
             Quando c'è un link ad una cartella contenente più stagioni
         """
+        if url:
+            data = support.match(url).data
             actLike = 'episodios'
             addVideolibrary = False
             downloadEnabled = False
 
-        folderUrl = scrapertools.find_single_match(data, r'TUTTA L[EA] \w+\s+(?:&#8211;|-)\s+<a href="?([^" ]+)')
-        data = httptools.downloadpage(folderUrl, disable_directIP=True).data
-        patron = r'<td>(?P<title>[^<]+)<td><a [^>]+href="(?P<url>[^"]+)[^>]+>'
+            patron = r'<tr><td>(?P<title>[^<]+)<td><span [^>].+?><a [^>]+href="(?P<url>[^"]+)[^>]+>'
             sceneTitle = True
             # debug = True
 
@@ -154,7 +156,7 @@ def episodios(item):
 
     # debugBlock=True
     data = support.match(item.url, headers=headers).data
-    folderItemlist = folder(item, data) if '<p>TUTTA L' in data else []
+    folderItemlist = folder(item, scrapertools.find_single_match(data, r'TUTT[EA] L[EA] \w+\s+(?:&#8211;|-)\s+<a href="?([^" ]+)'))
 
     patronBlock = r'(?P<block>sp-head[^>]+>\s*(?:STAGION[EI]\s*(?:(?:DA)?\s*[0-9]+\s*A)?\s*[0-9]+|MINISSERIE)(?::\s*PARTE\s*[0-9]+)? - (?P<lang>[^-<]+)(?:- (?P<quality>[^-<]+))?.*?<\/div>.*?)spdiv[^>]*>'
     patron = r'(?:/>|<p>|<strong>)(?P<other>.*?(?P<episode>[0-9]+(?:&#215;|×)[0-9]+)\s*(?P<title2>.*?)?(?:\s*&#8211;|\s*-|\s*<).*?)(?:<\/p>|<br)'
@@ -194,7 +196,6 @@ def findvideos(item):
 
     def load_links(itemlist, re_txt, desc_txt, quality=""):
         streaming = scrapertools.find_single_match(data, re_txt).replace('"', '')
-        logger.debug('STREAMING', streaming)
         logger.debug('STREAMING=', streaming)
         matches = support.match(streaming, patron = r'<td><a.*?href=([^ ]+) [^>]+>([^<]+)<').matches
         for scrapedurl, scrapedtitle in matches:
@@ -218,12 +219,9 @@ def findvideos(item):
     # Estrae i contenuti - Streaming 3D
     load_links(itemlist, '<strong>Streamin?g 3D[^<]+</strong>(.*?)cbtable', "Streaming 3D")
 
-    itemlist = support.server(item, itemlist=itemlist)
     # Extract the quality format
     patronvideos = r'([\w.]+)</strong></div></td>'
-    support.addQualityTag(item, itemlist, data, patronvideos)
-
-    return itemlist
+    return support.server(item, itemlist=itemlist, patronTag=patronvideos)
 
     # Estrae i contenuti - Download
     # load_links(itemlist, '<strong>Download:</strong>(.*?)<tableclass=cbtable height=30>', "aqua", "Download")

channels/cinemalibero.json

@@ -2,7 +2,7 @@
 	"id": "cinemalibero",
 	"name": "Cinemalibero",
 	"language": ["ita"],
-	"active": true,
+	"active": false,
 	"thumbnail": "cinemalibero.png",
 	"banner": "cinemalibero.png",
 	"categories": ["movie","tvshow","anime"],

channels/cinemalibero.py

@@ -7,8 +7,15 @@ import re
 
 from core import httptools, support, scrapertools
 from core.item import Item
-from platformcode import config
+from core.support import typo
+from platformcode import config, logger
+import sys
 
+from platformcode.logger import debug
+if sys.version_info[0] >= 3:
+    from concurrent import futures
+else:
+    from concurrent_py2 import futures
 
 # rimanda a .today che contiene tutti link a .plus
 # def findhost(url):
@@ -53,11 +60,13 @@ def peliculas(item):
         patron = r'<div class="col-lg-3">[^>]+>[^>]+>\s<a href="(?P<url>[^"]+)".+?url\((?P<thumb>[^\)]+)\)">[^>]+>(?P<title>[^<]+)<[^>]+>[^>]+>(?:[^>]+>)?\s?(?P<rating>[\d\.]+)?[^>]+>.+?(?:[ ]\((?P<year>\d{4})\))?<[^>]+>[^>]+>(.?[\d\-x]+\s\(?(?P<lang>[sSuUbBiItTaA\-]+)?\)?\s?(?P<quality>[\w]+)?[|]?\s?(?:[fFiInNeE]+)?\s?\(?(?P<lang2>[sSuUbBiItTaA\-]+)?\)?)?'
         pagination = 25
     elif item.contentType == 'movie':
-        patron = r'<a href="(?P<url>[^"]+)" title="(?P<title>.+?)(?:[ ]\[(?P<lang>[sSuUbB\-iItTaA]+)\])?(?:[ ]\((?P<year>\d{4})\))?"\s*alt="[^"]+"\s*class="[^"]+"(?: style="background-image: url\((?P<thumb>.+?)\)">)?\s*<div class="voto">[^>]+>[^>]+>.(?P<rating>[\d\.a-zA-Z\/]+)?[^>]+>[^>]+>[^>]+>(?:<div class="genere">(?P<quality>[^<]+)</div>)?'
+        # action = 'findvideos'
+        patron = r'<a href="(?P<url>[^"]+)" title="(?P<title>.+?)(?:[ ]\[(?P<lang>[sSuUbB\-iItTaA]+)\])?(?:[ ]\((?P<year>\d{4})?\))?"\s*alt="[^"]+"\s*class="[^"]+"(?: style="background-image: url\((?P<thumb>.+?)\)">)?\s*<div class="voto">[^>]+>[^>]+>.(?P<rating>[\d\.a-zA-Z\/]+)?[^>]+>[^>]+>[^>]+>(?:<div class="genere">(?P<quality>[^<]+)</div>)?'
         if item.args == 'update':
             patronBlock = r'<section id="slider">(?P<block>.*?)</section>'
-            patron = r'<a href="(?P<url>(?:https:\/\/.+?\/(?P<title>[^\/]+[a-zA-Z0-9\-]+)(?P<year>\d{4})))/".+?url\((?P<thumb>[^\)]+)\)">'
+            patron = r'<a href="(?P<url>(?:https:\/\/.+?\/(?P<title>[^\/]+[a-zA-Z0-9\-]+)(?P<year>\d{4})?))/".+?url\((?P<thumb>[^\)]+)\)">'
     elif item.contentType == 'tvshow':
+        # action = 'episodios'
         if item.args == 'update':
             patron = r'<a href="(?P<url>[^"]+)"[^<]+?url\((?P<thumb>.+?)\)">\s*?<div class="titolo">(?P<title>.+?)(?: &#8211; Serie TV)?(?:\([sSuUbBiItTaA\-]+\))?[ ]?(?P<year>\d{4})?</div>\s*?(?:<div class="genere">)?(?:[\w]+?\.?\s?[\s|S]?[\dx\-S]+?\s\(?(?P<lang>[iItTaA]+|[sSuUbBiItTaA\-]+)\)?\s?(?P<quality>[HD]+)?|.+?\(?(?P<lang2>[sSuUbBiItTaA\-]+)?\)?</div>)'
             pagination = 25
@@ -89,31 +98,79 @@ def peliculas(item):
 def episodios(item):
     data = item.data
     # debug=True
+
     if item.args == 'anime':
-        support.info("Anime :", item)
-        # blacklist = ['Clipwatching', 'Verystream', 'Easybytez', 'Flix555', 'Cloudvideo']
-        patron = r'<a target=(?P<url>[^>]+>(?P<title>Episodio\s(?P<episode>\d+))(?::)?(?:(?P<title2>[^<]+))?.*?(?:<br|</p))'
+        logger.debug("Anime :", item)
+        patron = r'<a target=(?P<url>[^>]+>(?P<title>Episodio\s(?P<episode>\d+))(?::)?(?:(?P<title2>[^<]+))?.*?(?:<br|</p))|(?P<data>.+)'
         patronBlock = r'(?:Stagione (?P<season>\d+))?(?:</span><br />|</span></p>|strong></p>)(?P<block>.*?)(?:<div style="margin-left|<span class="txt_dow">)'
         item.contentType = 'tvshow'
-    elif item.args == 'serie':
-        support.info("Serie :", item)
-        patron = r'(?:>| )(?P<episode>\d+(?:x|×|&#215;)\d+)[;]?[ ]?(?:(?P<title>[^<–-]+)(?P<data>.*?)|(\2[ ])(?:<(\3.*?)))(?:</a><br /|</a></p|$)'
-        patronBlock = r'>(?:[^<]+[Ss]tagione\s|[Ss]tagione [Uu]nica)(?:(?P<lang>iTA|ITA|Sub-ITA|Sub-iTA))?.*?</strong>(?P<block>.+?)(?:<strong|<div class="at-below)'
+    elif item.args == 'sport':
+        logger.debug("Sport :", item)
+        patron = r'(?:/>|<p>)\s*(?P<title>[^-]+)-(?P<data>.+?)(?:<br|</p)'
+        patronBlock = r'</strong>\s*</p>(?P<block>.*?</p>)'
+        item.contentType = 'tvshow'
+    elif item.args == 'serie' or item.contentType == 'tvshow':
+        logger.debug("Serie :", item)
+        patron = r'(?:/>|<p>)\s*(?:(?P<episode>\d+(?:x|×|&#215;)\d+|Puntata \d+)(?:-(?P<episode2>\d+))?[;]?[ ]?(?P<title>[^<–-]+))?(?P<data>.*?)(?:<br|</p)'
+        patronBlock = r'Stagione\s(?:[Uu]nica)?(?:(?P<lang>iTA|ITA|Sub-ITA|Sub-iTA))?.*?</strong>(?P<block>.+?)(?:strong>|<div class="at-below)'
         item.contentType = 'tvshow'
     else:
         patron = r'(?P<title>\s*[0-9]{2}/[0-9]{2}/[0-9]{4})(?P<data>.*?)(?:<br|</p)'
 
-    def itemHook(item):
-        if not scrapertools.find_single_match(item.title, r'(\d+x\d+)'):
-            item.title = re.sub(r'(\d+) -', '1x\\1', item.title)
-        return item
+    def itemHook(it):
+        if not scrapertools.find_single_match(it.title, r'(\d+x\d+)'):
+            it.title = re.sub(r'(\d+) -', '1x\\1', it.title)
+        return it
+
+    def itemlistHook(itl):
+        ret = []
+        if item.args == 'sport':
+            return itl
+        # support.dbg()
+        for it in itl:
+            ep = scrapertools.find_single_match(it.title, r'(\d+x\d+)')
+            if not ep and 'http' in it.data:  # stagione intera
+                # from lib import unshortenit
+                # data = unshortenit.findlinks(it.data)
+                episodes = {}
+
+                def get_ep(s):
+                    srv_mod = __import__('servers.%s' % s.server, None, None, ["servers.%s" % s.server])
+                    if hasattr(srv_mod, 'get_filename'):
+                        title = srv_mod.get_filename(s.url)
+                        if item.args == 'anime':
+                            ep = title
+                        else:
+                            ep = scrapertools.get_season_and_episode(title)
+                        if ep:
+                            if ep not in episodes:
+                                episodes[ep] = []
+                            episodes[ep].append(s)
+
+                servers = support.server(item, it.data, CheckLinks=False, Download=False, Videolibrary=False)
+                # for s in servers:
+                #     get_ep(s)
+                # ottengo l'episodio dal nome del file
+                with futures.ThreadPoolExecutor() as executor:
+                    for s in servers:
+                        executor.submit(get_ep, s)
+                # logger.debug(it.contentLanguage)
+                if item.args != 'anime':
+                    for ep in episodes:
+                        ret.append(it.clone(title=typo(ep, 'bold') + typo(it.contentLanguage, '_ [] color kod bold'),
+                                 servers=[srv.tourl() for srv in episodes[ep]], contentSeason=int(ep.split('x')[0]), contentEpisodeNumber=int(ep.split('x')[1])))
+                else:
+                    ret.extend([it.clone(title=typo(ep, 'bold') + typo(it.contentLanguage, '_ [] color kod bold'),
+                                         servers=[srv.tourl() for srv in episodes[ep]]) for ep in episodes])
+            elif ep:
+                ret.append(it)
+        return sorted(ret, key=lambda i: i.title)
 
     return locals()
 
 
 @support.scrape
 def genres(item):
-
     action='peliculas'
     patron_block=r'<div id="bordobar" class="dropdown-menu(?P<block>.*?)</li>'
     patronMenu=r'<a class="dropdown-item" href="(?P<url>[^"]+)" title="(?P<title>[A-z]+)"'
@@ -122,7 +179,7 @@ def genres(item):
 
 
 def search(item, texto):
-    support.info(item.url,texto)
+    logger.debug(item.url,texto)
     texto = texto.replace(' ', '+')
     item.url = host + "/?s=" + texto
     # item.contentType = 'tv'
@@ -133,11 +190,12 @@ def search(item, texto):
     except:
         import sys
         for line in sys.exc_info():
-            support.info("%s" % line)
+            logger.error("%s" % line)
     return []
 
+
 def newest(categoria):
-    support.info('newest ->', categoria)
+    logger.debug('newest ->', categoria)
     itemlist = []
     item = Item()
     item.args = 'newest'
@@ -151,47 +209,84 @@ def newest(categoria):
     except:
         import sys
         for line in sys.exc_info():
-            support.info('newest log: ', (line))
+            logger.error('newest log: ', (line))
         return []
 
     return itemlist
 
 
 def check(item):
-    support.info()
     data = support.match(item.url, headers=headers).data
+
     if data:
-        ck = support.match(data, patron=r'Supportaci condividendo quest[oa] ([^:]+)').match.lower()
+        ck = str(support.match(data, patronBlock=r'Genere:(.*?)</span>', patron=r'tag">([^<]+)').matches).lower()
 
-        if ck == 'serie tv':
-            item.contentType = 'tvshow'
-            item.args = 'serie'
-            item.data = data
-            return episodios(item)
-
-        elif ck == 'anime':
-            item.contentType = 'tvshow'
+        if 'serie tv' in ck or 'anime' in ck or 'wrestling wwe' in ck :# in ['serie tv', 'wrestling wwe', 'anime']:
+            if 'anime' in ck:
                 item.args = 'anime'
-            item.data = data
-            return episodios(item)
-
-        elif ck == 'film':
-            item.contentType = 'movie'
-            item.data = data
-            return findvideos(item)
-
+            elif 'sport' in ck or 'wrestling' in ck:
+                item.args = 'sport'
             else:
+                item.args = 'serie'
             item.contentType = 'tvshow'
             item.data = data
             itemlist = episodios(item)
             if not itemlist:
-                item.contentType = 'movie'
                 item.data = data
                 return findvideos(item)
+        else:
+            item.contentType = 'movie'
+            item.data = data
+            # item.action = 'findvideos'
+            return findvideos(item)
+
         return itemlist
 
 
 def findvideos(item):
-    support.info()
-    item.data = item.data.replace('http://rapidcrypt.net/verys/', '').replace('http://rapidcrypt.net/open/', '') #blocca la ricerca
-    return support.server(item, data=item.data)
+    def filter_ep(s):
+        srv_mod = __import__('servers.%s' % s.server, None, None, ["servers.%s" % s.server])
+        if hasattr(srv_mod, 'get_filename'):
+            title = srv_mod.get_filename(s.url)
+            # support.dbg()
+            if scrapertools.get_season_and_episode(title) == str(item.contentSeason) + "x" + str(
+                    item.contentEpisodeNumber).zfill(2):
+                servers.append(s)
+    logger.debug()
+    # support.dbg()
+    if item.servers:
+        return support.server(item, itemlist=[Item().fromurl(s) for s in item.servers])
+    if not item.data:
+        item.data = httptools.downloadpage(item.url)
+    data = scrapertools.find_single_match(item.data, '<div class="at-above-post addthis_tool"(.*?)(?:<div class="at-below-post|[dD][oO][wW][nN][lL][oO][aA][dD])')
+    if data:
+        item.data = data
+
+    servers = []
+    # if item.args == 'anime':
+    #     if item.urls:  # this is a episode
+    #         return support.server(item, itemlist=[Item(url=support.unshortenit.FileCrypt().unshorten(u)) for u in item.urls])
+    #     itemlist = []
+    #     episodes = {}
+    #     for uri in support.unshortenit.FileCrypt().find(item.data):
+    #         for ep in support.unshortenit.FileCrypt(uri).list_files():
+    #             ep = ('.'.join(ep[0].split('.')[:-1]), ep[1])  # remove extension
+    #             if not ep[0] in episodes:
+    #                 episodes[ep[0]] = []
+    #             episodes[ep[0]].append(ep[1])
+    #     for ep in episodes.keys():
+    #         itemlist.append(item.clone(title=ep, urls=episodes[ep], action='findvideos', data=''))
+    #     return itemlist
+    total_servers = support.server(item, data=item.data)
+
+    if item.contentType == 'episode' and len(set([srv.server for srv in total_servers])) < len([srv.server for srv in total_servers]):
+        # i link contengono più puntate, cerco quindi quella selezionata
+        with futures.ThreadPoolExecutor() as executor:
+            for s in total_servers:
+                if s.server:
+                    executor.submit(filter_ep, s)
+                else:
+                    servers.append(s)
+        return servers
+    else:
+        return total_servers

channels/cinetecadibologna.json

@@ -6,6 +6,6 @@
 	"thumbnail": "cinetecadibologna.png",
 	"banner": "cinetecadibologna.png",
 	"categories": ["documentary"],
-	"not_active":["include_in_newest_peliculas", "include_in_newest_series", "include_in_newest_anime"],
+	"not_active":["include_in_newest_peliculas", "include_in_newest_series", "include_in_newest_anime", "include_in_global_search"],
 	"settings": []
 }

channels/dinostreaming.json

@@ -0,0 +1,11 @@
+{
+    "id": "dinostreaming",
+    "name": "DinoStreaming",
+    "language": ["ita"],
+    "active": true,
+    "thumbnail": "dinostreaming.png",
+    "banner": "dinostreaming.png",
+    "categories": ["movie"],
+    "settings": [],
+    "not_active": ["include_in_newest"]
+}

channels/dinostreaming.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Dinostreaming
+# by ilmich
+# ------------------------------------------------------------
+
+from core import httptools, support
+from core.item import Item
+from platformcode import logger
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    film = [('Film al cinema',['/film-category/al-cinema/', 'peliculas']),
+            ('Generi',['', 'genres']),
+            ]
+    search = ''
+    return locals()
+
+@support.scrape
+def genres(item):
+    action = 'peliculas'
+    blacklist = ['Seguici su Telegram',]
+    patronMenu = r'<li class="elementor-icon-list-item">.*?href="(?P<url>.*?)".*?text">(?P<title>.*?)</span>'
+    
+    return locals()
+
+@support.scrape
+def peliculas(item):
+    if not item.args == 'search': # pagination not works
+        if not item.nextpage:
+            item.page = 1
+        else:
+            item.page = item.nextpage
+
+        if not item.parent_url:
+            item.parent_url = item.url
+
+        item.nextpage = item.page + 1
+        nextPageUrl = "{}/page/{}".format(item.parent_url, item.nextpage)
+        
+        resp = httptools.downloadpage(nextPageUrl, only_headers = True)
+        if (resp.code > 399): # no more elements
+            nextPageUrl = ''
+
+    patron = r'<div data-elementor-type="loop-item".*?<a.*?url="(?P<thumb>[^"]+).*?<a href=\"(?P<url>[^"]+)\">(?P<title>.*?)</a>.*?<span class="elementor-heading-title elementor-size-default">(?P<year>.*?)</span>'
+
+    def itemlistHook(itemlist):
+        return itemlist[:-1:]
+    return locals()
+
+def search(item, text):
+    item.url = "{}/?{}".format(host, support.urlencode({'s': text}))
+    item.args = 'search'
+
+    try:
+        return peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("search except: %s" % line)
+        return []
+
+def findvideos(item):
+    support.info()    
+    data = httptools.downloadpage(item.url).data
+    video_url = support.match(data, patron=r'<a href="([^"]+)" rel="nofollow" title="Guarda il film in streaming">' ).match
+    if (video_url == ''):
+        return []
+
+    item.url = video_url
+    itemlist = support.server(item)
+    return itemlist
+

channels/discoveryplus.py

@@ -2,196 +2,279 @@
 # ------------------------------------------------------------
 # Canale per Rai Play
 # ------------------------------------------------------------
+import functools
 
-import requests
-from core import support, jsontools
+import requests, uuid
+from core import jsontools, support, httptools
 from platformcode import logger, config
+
+
 typo = support.typo
 session = requests.Session()
+session.request = functools.partial(session.request, timeout=httptools.HTTPTOOLS_DEFAULT_DOWNLOAD_TIMEOUT)
 host = support.config.get_channel_url()
+deviceId = uuid.uuid4().hex
 
-token = session.get('https://disco-api.discoveryplus.it/token?realm=dplayit').json()['data']['attributes']['token']
-
-api = "https://disco-api.discoveryplus.it"
-headers = {'User-Agent': 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0',
+# domain = 'https://eu1-prod-direct.discoveryplus.com'
+domain = 'https://' + session.get("https://prod-realmservice.mercury.dnitv.com/realm-config/www.discoveryplus.com%2Fit%2Fepg").json()["domain"]
+token = session.get('{}/token?deviceId={}&realm=dplay&shortlived=true'.format(domain, deviceId)).json()['data']['attributes']['token']
+session.headers = {'User-Agent': httptools.get_user_agent(), #'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0',
                    'Referer': host,
-           'Cookie' : 'st=' + token}
-
-def Dict(item):
-    global pdict
-    pdict = session.get(api + '/cms/routes/{}?decorators=viewingHistory&include=default'.format(item.args), headers=headers).json()['included']
-
+                   'Origin': host,
+                   'Cookie': 'st={}'.format(token),
+                   'content-type': 'application/json',
+                   'x-disco-client': 'WEB:UNKNOWN:dplus_us:2.46.0',
+                   'x-disco-params': 'realm=dplay,siteLookupKey=dplus_it'}
 
 @support.menu
 def mainlist(item):
     top =  [('Dirette {bold}', ['', 'live']),
-            ('Programmi {bullet bold tv}', ['', 'peliculas', 'programmi']),
-            ('Generi {bullet bold tv}', ['', 'genres'])]
+            ('Programmi {bullet bold tv}', ['', 'programs', 'programmi'])]
 
     search = ''
 
     return locals()
 
 
-def liveDict():
-    livedict = {}
-
-    for key in session.get(api + '/cms/routes/canali?decorators=viewingHistory&include=default', headers=headers).json()['included']:
-
-        if key['type'] == 'channel' and key.get('attributes',{}).get('hasLiveStream', '') and 'Free' in key.get('attributes',{}).get('packages', []):
-            title = key['attributes']['name']
-            livedict[title] = {}
-            livedict[title]['plot'] = key['attributes']['description']
-            livedict[title]['url'] = '{}/canali/{}'.format(host, key['attributes']['alternateId'])
-            livedict[title]['id'] = key['id']
-    return livedict
-
-
 def search(item, text):
     itemlist = []
-    item.args = 'search'
+
     item.text = text
+
     try:
         itemlist = peliculas(item)
     except:
         import sys
         for line in sys.exc_info():
-            support.logger.error("%s" % line)
+            logger.error(line)
 
     return itemlist
 
 
 def live(item):
     logger.debug()
+
     itemlist =[]
-    for name, values in liveDict().items():
-        itemlist.append(item.clone(title=typo(name,'bold'), fulltitle=name, plot=values['plot'], url=values['url'], id=values['id'], action='play', forcethumb=True, no_return=True))
+    # data = session.get(domain + '/cms/routes/epg?include=default').json()['included']
+    data = session.get(domain + '/cms/routes/home?include=default&decorators=playbackAllowed').json()['included']
+
+    for key in data:
+
+        if key['type'] == 'channel' and key.get('attributes',{}).get('hasLiveStream', '') and 'Free' in key.get('attributes',{}).get('packages', []):
+            itemlist.append(item.clone(title = typo(key['attributes']['name'], 'bold'),
+                                       fulltitle = key['attributes']['name'],
+                                       plot = key['attributes'].get('description', ''),
+                                       url = "{}/canali/{}".format(host, key['attributes']['alternateId']),
+                                       id = key['id'],
+                                       action = 'findvideos'))
     return support.thumb(itemlist, live=True)
 
 
+def programs(item):
+    logger.debug()
+
+    itemlist = []
+    data = session.get(domain + '/cms/routes/browse?include=default').json()['included']
+    images = {key['id'] : key['attributes']['src'] for key in data if key['type'] == 'image'}
+
+    channels = {}
+    for key in data:
+        if key['type'] == 'link' and 'Free' in key['attributes']['packages']:
+            logger.debug(jsontools.dump(key))
+            _title = key['attributes'].get('title', key['attributes'].get('name',''))
+            _id = key['relationships']['linkedContent']['data']['id']
+            _thumb = images.get(key['relationships'].get('images', {}).get('data',[{}])[0].get('id'))
+            channels[_title] ={'id':_id, 'thumb':_thumb}
+
+    itemlist = [item.clone(title='Tutti', id=channels['Tutti']['id'], action='peliculas'),
+                item.clone(title='Generi', id=channels['Tutti']['id'], action='genres'),
+                item.clone(title='Per canale', channels=channels, action='channels')]
+
+    return support.thumb(itemlist)
+
+
 def genres(item):
-    item.action = 'peliculas'
-    itemlist = [
-        item.clone(title='Attualità e inchiesta', args='genere/attualita-e-inchiesta'),
-        item.clone(title='Beauty and style', args='genere/beauty-and-style'),
-        item.clone(title='Serie TV', args='genere/serie-tv'),
-        item.clone(title='Casa', args='genere/casa'),
-        item.clone(title='Comedy', args='genere/comedy'),
-        item.clone(title='Crime', args='genere/crime'),
-        item.clone(title='Documentari', args='genere/documentari'),
-        # item.clone(title='Discovery + Originals', args='genere/discoveryplus-original'),
-        item.clone(title='Food', args='genere/food'),
-        item.clone(title='Medical', args='genere/medical'),
-        item.clone(title='Motori', args='genere/motori'),
-        item.clone(title='Natura', args='genere/natura'),
-        item.clone(title='Paranormal', args='genere/paranormal'),
-        item.clone(title='People', args='genere/people'),
-        item.clone(title='Real Adventure', args='genere/real-adventure'),
-        item.clone(title='Real Life', args='genere/real-life'),
-        item.clone(title='Scienza e Spazio', args='genere/scienza-e-spazio'),
-        item.clone(title='Sex and love', args='genere/sex-and-love'),
-        item.clone(title='Sport', args='genere/sport'),
-        item.clone(title='Talent Show', args='genere/talent-show'),
-        ]
+    logger.debug()
+
+    itemlist = []
+    data = session.get('{}/cms/collections/{}?include=default'. format(domain, item.id)).json()['included']
+    collection = {k['id']: k['relationships'].get('show', k['relationships'].get('collection'))['data']['id'] for k in data if k['type'] == 'collectionItem'}
+
+    included = {}
+    for key in data:
+        if key.get('relationships', {}).get('items') and key['type'] == 'collection' and key['attributes']['title'] not in ['A-Z', 'I più visti']:
+            included[key['attributes']['title']] = [k['id'] for k in key['relationships']['items']['data']]
+
+    for title, values in included.items():
+        itemlist.append(item.clone(title=title, action='peliculas', filter=[collection[k] for k in values]))
+
+    itemlist.sort(key=lambda it: it.title)
+
+    return support.thumb(itemlist, genre=True)
+
+
+def channels(item):
+    logger.debug()
+
+    itemlist = [item.clone(title=k, id=v['id'], thumbnail=v['thumb'], action='peliculas') for k, v in item.channels.items() if k !='Tutti']
+    itemlist.sort(key=lambda it: it.title)
+
     return itemlist
 
 
 def peliculas(item):
     logger.debug()
-    itemlist =[]
-    if 'search' in item.args:
-        pdict = session.get('{}/content/shows?include=genres,images,primaryChannel.images,contentPackages&page[size]=12&query={}'.format(api, item.text), headers=headers).json()['data']
-    else:
-        pdict = session.get('{}/cms/routes/{}?decorators=viewingHistory&include=default'.format(api, item.args), headers=headers).json()['included']
-    images = list(filter(lambda x: x['type'] == 'image', pdict))
 
-    for key in pdict:
-        if key['type'] == 'show' and 'Free' in str(key.get('relationships',{}).get('contentPackages',{}).get('data',[])):
-            title = key['attributes']['name']
-            plot = key['attributes'].get('description','')
-            url = '{}/programmi/{}'.format(host, key['attributes']['alternateId'])
-            seasons = key['attributes']['seasonNumbers']
-            thumbs = [image['attributes']['src'] for image in images if image['id'] == key['relationships']['images']['data'][0]['id']]
-            thumb = thumbs[0] if thumbs else item.thumbnail
-            fanarts = [image['attributes']['src'] for image in images if len(key['relationships']['images']['data']) > 1 and image['id'] == key['relationships']['images']['data'][1]['id']]
-            fanart = fanarts[0] if fanarts else item.fanart
+    itemlist =[]
+
+    if item.text:
+        data = session.get('{}/cms/routes/search/result?include=default&contentFilter[query]={}'.format(domain, item.text)).json()['included']
+    else:
+        data = session.get('{}/cms/collections/{}?include=default'.format(domain, item.id)).json()['included']
+
+    images = {key['id'] : key['attributes']['src'] for key in data if key['type'] == 'image'}
+
+    for key in data:
+        if key['type'] == 'show' and 'Free' in str(key.get('relationships',{}).get('contentPackages',{}).get('data',[])) and key['attributes']['episodeCount']:
+
+            if item.filter and key['id'] not in item.filter:
+                continue
+
+            thumbId = key['relationships'].get('images',{}).get('data', [{},{},{}])[2].get('id', '')
+            fanartId = key['relationships'].get('images',{}).get('data', [{}])[0].get('id', '')
             itemlist.append(
-                item.clone(title=typo(title,'bold'),
-                            fulltitle=title,
-                            plot=plot,
-                            url=url,
+                item.clone(title=typo(key['attributes']['name'],'bold'),
+                           plot=key['attributes'].get('description',''),
                            programid=key['attributes']['alternateId'],
-                            id=key['id'],
-                            seasons=seasons,
-                            action='episodios',
-                            thumbnail=thumb,
-                            fanart=fanart,
+                           seasons=key['attributes']['seasonNumbers'],
+                           action='seasons',
+                           thumbnail=images[thumbId] if thumbId else item.thumbnail,
+                           fanart=images[fanartId] if fanartId else item.fanart,
                            contentType='tvshow'))
 
+    itemlist.sort(key=lambda it: it.title)
+
+    if not itemlist:
+        from core.item import Item
+        itemlist = [Item(title='Nessun Contenuto Free Disponibile', thumbnail=support.thumb('info'))]
+
+    return itemlist
+
+
+def seasons(item):
+    logger.debug()
+
+    itemlist = []
+    data = session.get('{}/cms/routes/show/{}?include=default'.format(domain, item.programid)).json()['included']
+
+    for key in data:
+        if key['type'] == 'collection' and 'filters' in key['attributes']['component']:
+            for option in key['attributes']['component']['filters'][0]['options']:
+                itemlist.append(item.clone(title="Stagione {}".format(option['value']),
+                                           season=int(option['value']),
+                                           seasonparams=option['parameter'],
+                                           showparams=key['attributes']['component']['mandatoryParams'],
+                                           id=key['id'],
+                                           contentType='season',
+                                           action='episodios'))
+            break
+
+        if key['type'] == 'collection' and 'title' in key['attributes']:
+            itemlist.append(
+                item.clone(title=typo(key['attributes']['title'],'bold'),
+                           plot=key['attributes'].get('description',''), 
+                           programid=key['attributes']['alias'],
+                           id=key['id'],
+                           action='episodios',
+                           contentType='season'))
+
     return itemlist
 
 
 def episodios(item):
     logger.debug()
+
     itemlist =[]
-    pdict = session.get(api + '/cms/routes/programmi/{}?decorators=viewingHistory&include=default'.format(item.programid), headers=headers).json()['included']
+    data = session.get('{}/cms/collections/{}?include=default&{}&{}'.format(domain, item.id, item.seasonparams, item.showparams)).json()['included']
+    images = {key['id'] : key['attributes']['src'] for key in data if key['type'] == 'image'}
 
-    for key in pdict:
-        if key['type'] == 'collection' and key.get('attributes',{}).get('component',{}).get('id', '') == 'tabbed-content':
-            mandatory = key['attributes']['component'].get('mandatoryParams','')
-            if not mandatory: return [support.Item(title='CONTENUTO PLUS')]
-            for option in key['attributes']['component']['filters'][0]['options']:
-                url = '{}/cms/collections/{}?decorators=viewingHistory&include=default&{}&{}'.format(api, key['id'], mandatory, option['parameter'])
-                seasons = []
-                season = {}
-                try:
-                    season = session.get(url, headers=headers).json()
-                    seasons.append(season['included'])
-                    pages = season['data'].get('meta',{}).get('itemsTotalPages', 0)
-                    if pages:
-                        for page in range(2,pages + 1):
-                            url = '{}/cms/collections/{}?decorators=viewingHistory&include=default&{}&{}&page[items.number]={}'.format(api, key['id'], mandatory, option['parameter'], page)
-                            logger.debug(url)
-                            season = session.get(url, headers=headers).json()['included']
-                            seasons.append(season)
-                except:
-                    pass
-
-                for season in seasons:
-                    for episode in season:
-                        if episode['type'] == 'video' and 'Free' in episode['attributes']['packages']:
-                            title = '{}x{:02d} - {}'.format(option['id'], episode['attributes']['episodeNumber'], episode['attributes']['name'])
-                            plot = episode['attributes']['description']
-                            itemlist.append(
-                                item.clone(title=typo(title,'bold'),
-                                           fulltitle=title,
-                                           plot=plot,
-                                           id=episode['id'],
-                                           action='play',
+    for key in data:
+        if key['type'] == 'video' and 'Free' in str(key.get('relationships',{}).get('contentPackages',{}).get('data',[])):
+            if item.season:
+                itemlist.append(item.clone(title = "{}x{:02d} - {}".format(item.season, key['attributes']['episodeNumber'], key['attributes']['name']),
+                                       plot = key['attributes']['description'],
+                                       episode = key['attributes']['episodeNumber'],
                                        contentType = 'episode',
-                                           season=option['id'],
-                                           episode=episode['attributes']['episodeNumber'],
-                                           forcethumb=True,
-                                           no_return=True))
+                                       action = 'findvideos',
+                                       thumbnail = images[key['relationships']['images']['data'][0]['id']],
+                                       id=key['id']))
+            else:
+                itemlist.append(item.clone(title = key['attributes']['name'],
+                                       plot = key['attributes']['longDescription'],
+                                       contentType = 'episode',
+                                       action = 'findvideos',
+                                       thumbnail = images[key['relationships']['images']['data'][0]['id']],
+                                       id=key['id']))
+
+    itemlist.sort(key=lambda it: it.episode)
+
+    if not itemlist:
+        from core.item import Item
+        itemlist = [Item(title='Nessun Episodio Free Disponibile', thumbnail=support.thumb('info'))]
 
-    if itemlist: itemlist.sort(key=lambda it: (int(it.season), int(it.episode)))
     return itemlist
 
 
-def play(item):
-    if item.livefilter:
-        item.id = liveDict()[item.livefilter]['id']
-        item.fulltitle = item.livefilter
-        item.forcethumb = True
-        item.no_return = True
-        support.thumb(item, live=True)
-    if item.contentType == 'episode': data = session.get('{}/playback/v2/videoPlaybackInfo/{}?usePreAuth=true'.format(api, item.id), headers=headers).json().get('data',{}).get('attributes',{})
-    else: data = session.get('{}/playback/v2/channelPlaybackInfo/{}?usePreAuth=true'.format(api, item.id), headers=headers).json().get('data',{}).get('attributes',{})
-    if data.get('protection', {}).get('drm_enabled',True):
-        item.url = data['streaming']['dash']['url']
+def findvideos(item):
+    logger.debug()
+
+    content = 'video' if item.contentType == 'episode' else 'channel'
+
+    post =  {content + 'Id': item.id,
+            'deviceInfo': {
+                'adBlocker': 'true',
+                'drmSupported': 'true',
+                'hwDecodingCapabilities': [],
+                'screen':{
+                    'width':1920,
+                    'height':1080
+                },
+                'player':{
+                    'width':1920,
+                    'height':1080
+                }
+            },
+            'wisteriaProperties':{
+                'advertiser': {
+                    'firstPlay': 0,
+                    'fwIsLat': 0
+                },
+                'device':{
+                    'browser':{
+                        'name': 'chrome',
+                        'version': config.get_setting("chrome_ua_version")
+                    },
+                    'type': 'desktop'
+                },
+                'platform': 'desktop',
+                'product': 'dplus_emea',
+                'sessionId': deviceId,
+                'streamProvider': {
+                    'suspendBeaconing': 0,
+                    'hlsVersion': 6,
+                    'pingConfig': 1
+                }
+            }
+        }
+
+    data = session.post('{}/playback/v3/{}PlaybackInfo'.format(domain, content), json=post).json().get('data',{}).get('attributes',{})
+    if data.get('streaming', [{}])[0].get('protection', {}).get('drmEnabled',False):
+        item.url = data['streaming'][0]['url']
         item.drm = 'com.widevine.alpha'
-        item.license = data['protection']['schemes']['widevine']['licenseUrl'] + '|PreAuthorization=' + data['protection']['drmToken'] + '|R{SSM}|'
+        item.license ="{}|PreAuthorization={}|R{{SSM}}|".format(data['streaming'][0]['protection']['schemes']['widevine']['licenseUrl'],
+	                      data['streaming'][0]['protection']['drmToken'])
     else:
-        item.url = data['streaming']['hls']['url']
+        item.url = data['streaming'][0]['url']
         item.manifest = 'hls'
-    return [item]
+
+    return support.server(item, itemlist=[item], Download=False, Videolibrary=False)

channels/dreamsub.json

@@ -2,7 +2,7 @@
     "id": "dreamsub",
     "name": "DreamSub",
     "language": ["ita", "sub-ita"],
-    "active": true,
+    "active": false,
     "thumbnail": "dreamsub.png",
     "banner": "dreamsub.png",
     "categories": ["anime", "vos"],

channels/dreamsub.py

@@ -88,7 +88,7 @@ def peliculas(item):
 
     if len(item.args) > 1 and item.args[0] == 'last':
         patronBlock = r'<div id="%s"[^>]+>(?P<block>.*?)<div class="vistaDettagliata"' % item.args[1]
-        patron = r'<li>\s*<a href="(?P<url>[^"]+)" title="(?P<title>[^"]+)" class="thumb">[^>]+>[^>]+>[^>]+>\s*[EePp]+\s*(?P<episode>\d+)[^>]+>\s<img src="(?P<thumb>[^"]+)"'
+        patron = r'<li>\s*<a href="(?P<url>[^"]+)" title="(?P<title>[^"]+)" class="thumb">[^>]+>[^>]+>[^>]+>\s*[EePp]+\s*(?P<episode>\d+)[^>]+>\s+<img src="(?P<thumb>[^"]+)"'
     else:
         patron = r'<div class="showStreaming">\s*<b>(?P<title>[^<]+)[^>]+>[^>]+>\s*<span>Lingua:\s*(?:DUB|JAP)?\s*(?P<lang>(?:SUB )?ITA)[^>]+>[<>br\s]+a href="(?P<url>[^"]+)"[^>]+>.*?--image-url:url\(/*(?P<thumb>[^\)]+).*?Anno di inizio</b>:\s*(?P<year>[0-9]{4})'
         patronNext = '<li class="currentPage">[^>]+><li[^<]+<a href="([^"]+)">'
@@ -104,12 +104,13 @@ def peliculas(item):
 @support.scrape
 def episodios(item):
     anime = True
+    # debug = True
     pagination = 100
 
     if item.data:
         data = item.data
 
-    patron = r'<div class="sli-name">\s*<a href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+)<'
+    patron = r'<div class="sli-name">\s*<a\s+href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+)<'
 
     return locals()
 

channels/dsda.json

@@ -1,10 +0,0 @@
-{
-	"id": "dsda",
-	"name": "D.S.D.A",
-	"language": ["ita"],
-	"active": false,
-	"thumbnail": "dsda.png",
-	"banner": "dsda.png",
-	"categories": ["documentary"],
-	"settings": []
-}

channels/dsda.py

@@ -1,140 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per documentaristreamingda
-# ------------------------------------------------------------
-
-from core import support
-from core.item import Item
-from platformcode import logger, config
-
-host = config.get_channel_url()
-
-@support.menu
-def mainlist(item):
-    docu = [('Documentari {bullet bold}',('/elenco-documentari','peliculas')),
-            ('Categorie {submenu}',('','menu')),
-            ('Cerca... {bullet bold}',('','search')),]
-    return locals()
-
-
-@support.scrape
-def menu(item):
-    action = 'peliculas'
-    patronMenu = r'<li class="menu-item menu-item-type-taxonomy[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+)<'
-    def fullItemlistHook(itemlist):
-        item_list = []
-        title_list = []
-        for item in itemlist:
-            if item.title not in title_list:
-                item_list.append(item)
-                title_list.append(item.title)
-        itemlist = item_list
-        return itemlist
-    return locals()
-
-def newest(categoria):
-    support.info()
-    item = Item()
-    try:
-        if categoria == "documentales":
-            item.url = host + "/elenco-documentari"
-            item.action = "peliculas"
-            return peliculas(item)
-
-    # Continua la ricerca in caso di errore
-    except:
-        import sys
-        for line in sys.exc_info():
-            support.logger.error("{0}".format(line))
-        return []
-
-
-def search(item, texto):
-    support.info(texto)
-    item.url = host + "/?s=" + texto
-    try:
-        return peliculas(item)
-    # Continua la ricerca in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-@support.scrape
-def peliculas(item):
-    blacklist = ['GUIDA PRINCIPIANTI Vedere film e documentari streaming gratis', 'Guida Dsda']
-    data = support.match(item).data
-    # debug =True
-    if item.args == 'collection':
-        if 'class="panel"' in data:
-            item.args = 'raccolta'
-            patron = r'class="title-episodio">(?P<title>[^<]+)<(?P<url>.*?)<p'
-            # patron = r'<a (?:style="[^"]+" )?href="(?P<url>[^"]+)"[^>]+>(?:[^>]+><strong>)?(?P<title>[^<]+)(?:</a>)?</strong'
-        else:
-            patron = r'<div class="cover-racolta">\s*<a href="(?P<url>[^"]+)"[^>]+>\s*<img width="[^"]+" height="[^"]+" src="(?P<thumb>[^"]+)".*?<p class="title[^>]+>(?P<title>[^<]+)<'
-    else:
-        patron = r'<article[^>]+>[^>]+>[^>]+>(?:<img width="[^"]+" height="[^"]+" src="(?P<thumb>[^"]+)"[^>]+>)?.*?<a href="(?P<url>[^"]+)"[^>]*>\s*(?P<title>[^<]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*<p>(?P<plot>[^<]+)<'
-        patronNext = r'<a class="page-numbers next" href="([^"]+)">'
-
-    # select category
-    def itemHook(item):
-        title = support.re.sub(r'(?:[Ss]erie\s*|[Ss]treaming(?:\s*[Dd][Aa])?\s*|[Cc]ollezione\s*|[Rr]accolta\s*|[Dd]ocumentari(?:o)?\s*)?','',item.fulltitle).strip()
-        if 'serie' in item.fulltitle.lower():
-            item.contentType = 'tvshow'
-            item.action = 'episodios'
-            item.contentSerieName = title
-            item.contentTitle = ''
-        elif 'collezion' in item.fulltitle.lower() or \
-             'raccolt' in item.fulltitle.lower() or \
-             'filmografia' in item.fulltitle.lower():
-            item.args = 'collection'
-            item.action = 'peliculas'
-            item.contentTitle = title
-            item.contentSerieName = ''
-        else:
-            item.contentTitle = title
-            item.contentSerieName = ''
-
-        item.title = support.typo(title,'bold')
-        item.fulltitle = item.show = title
-        return item
-    # remove duplicates
-    def fullItemlistHook(itemlist):
-        item_list = []
-        title_list = []
-        for item in itemlist:
-            if item.title not in title_list:
-                item_list.append(item)
-                title_list.append(item.title)
-        itemlist = item_list
-        return itemlist
-    return locals()
-
-@support.scrape
-def episodios(item):
-    html = support.match(item, patron=r'class="title-episodio">(\d+x\d+)')
-    data = html.data
-    if html.match:
-        patron = r'class="title-episodio">(?P<episode>[^<]+)<(?P<url>.*?)<p'
-    else:
-        patron = r'class="title-episodio">(?P<title>[^<]+)<(?P<url>.*?)<p'
-
-        # def itemlistHook(itemlist):
-        #     counter = 0
-        #     for item in itemlist:
-        #         episode = support.match(item.title, patron=r'\d+').match
-        #         if episode == '1':
-        #             counter += 1
-        #         item.title = support.typo(str(counter) + 'x' + episode.zfill(2) + support.re.sub(r'\[[^\]]+\](?:\d+)?','',item.title),'bold')
-        #     return itemlist
-    return locals()
-
-
-def findvideos(item):
-    support.info()
-    if item.args == 'raccolta' or item.contentType == 'episode':
-        return support.server(item, item.url)
-    else:
-        return support.server(item)

channels/eurostreaming.json

@@ -1,7 +1,7 @@
 {
     "id": "eurostreaming",
     "name": "Eurostreaming",
-    "active": true,
+    "active": false,
     "language": ["ita", "sub-ita"],
     "thumbnail": "eurostreaming.png",
     "banner": "eurostreaming.png",

channels/eurostreaming.py

@@ -4,7 +4,7 @@
 # by Greko
 # ------------------------------------------------------------
 
-from core import httptools, support
+from core import support
 from core.item import Item
 
 # def findhost(url):
@@ -20,7 +20,7 @@ def mainlist(item):
     support.info()
     tvshow = []
     anime = ['/category/anime-cartoni-animati/']
-    mix = [('Aggiornamenti {bullet bold} {TV}', ['/aggiornamento-episodi/', 'peliculas', 'newest']),
+    mix = [('Aggiornamenti {bullet bold} {TV}', ['/aggiornamento-episodi-nuovi/', 'peliculas', 'newest']),
            ('Archivio {bullet bold} {TV}', ['/category/serie-tv-archive/', 'peliculas'])]
     search = ''
 
@@ -42,14 +42,16 @@ def peliculas(item):
 
     return locals()
 
+
 @support.scrape
 def episodios(item):
     # debug = True
     data = support.match(item, headers=headers).data
     if 'clicca qui per aprire' in data.lower(): data = support.match(support.match(data, patron=r'"go_to":"([^"]+)"').match.replace('\\',''), headers=headers).data
     elif 'clicca qui</span>' in data.lower(): data = support.match(support.match(data, patron=r'<h2 style="text-align: center;"><a href="([^"]+)">').match, headers=headers).data
+
     patronBlock = r'</span>(?P<block>[a-zA-Z\s]+\d+(.+?)?(?:\()?(?P<lang>ITA|SUB ITA)(?:\))?.*?)</div></div>'
-    patron = r'(?P<season>\d+)&#\d+;(?P<episode>\d+(?:-\d+)?)\s*(?:</strong>|<em>)?\s*(?P<title>.*?)(?:–|-.+?-|–.+?–|–|em|.)?(?:/em.*?)?(?:<a (?P<other>.*?))?<br />'
+    patron = r'(?P<season>\d+)&#215;(?P<episode>\d+)(</strong>)*(?P<title>.*?)<(?P<other>.*?br/>)'
 
     def itemHook(i):
         i.url = item.url
@@ -83,7 +85,7 @@ def newest(categoria):
     item.contentType = 'tvshow'
     item.args = 'newest'
     try:
-        item.url = "%s/aggiornamento-episodi/" % host
+        item.url = "%s/aggiornamento-episodi-nuovi/" % host
         item.action = "peliculas"
         itemlist = peliculas(item)
     # Continua la ricerca in caso di errore
@@ -98,4 +100,10 @@ def newest(categoria):
 
 def findvideos(item):
     support.info()
-    return support.server(item, item.other)
+    itemlist = support.server(item, item.other)
+    # testo che tutti i link siano stati risolti
+    if support.logger.testMode:
+        if len(itemlist) < len(support.match(item.other, patron='<a href="([^"]+)').matches):
+            raise Exception('Manca qualche server')
+    return itemlist
+

channels/eurostreaming_actor.json

@@ -0,0 +1,10 @@
+{
+    "id": "eurostreaming_actor",
+    "name": "Eurostreaming Actor",
+    "active": true,
+    "language": ["ita","sub-ita"],
+    "thumbnail": "eurostreaming.png",
+    "banner": "eurostreaming.png",
+    "categories": ["tvshow","anime","vos"],
+    "settings": []
+}

channels/eurostreaming_actor.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Eurostreaming.Actor
+# by Napster32
+# ------------------------------------------------------------
+
+from core import support
+from core.item import Item
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    support.info()
+    tvshow = []
+    anime = ['/animazione/']
+    mix = [('Aggiornamenti {bullet bold} {TV}', ['/aggiornamento-episodi/', 'peliculas', 'newest'])]
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    action = 'episodios'
+
+    if item.args == 'newest':
+        item.contentType = 'episode'
+        patron = r'<span class="serieTitle" style="font-size:20px">(?P<title>[^<]+) –\s*<a href="(?P<url>[^"]+)"[^>]*>(?P<episode>\d+[×x]\d+-\d+|\d+[×x]\d+) (?P<title2>[^<\(]+)\s?\(?(?P<lang>SUB ITA)?\)?</a>'
+        patronNext = r'class="next".*?"(.+?)"'
+        
+    else:
+        patron = r'<div class="post-thumb">.*?<img src="(?P<thumb>[^"]+)".*?><a href="(?P<url>[^"]+)"[^>]+>(?P<title>.+?)[\<]'
+        patronNext = r'next.*?href="(.*?)"'
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    # debug = True
+    data = support.match(item, headers=headers).data
+    if 'clicca qui per aprire' in data.lower():
+        data = support.match(support.match(data, patron=r'"go_to":"([^"]+)"').match.replace('\\',''), headers=headers).data
+
+    elif 'clicca qui</span>' in data.lower():
+        data = support.match(support.match(data, patron=r'<h2 style="text-align: center;"><a href="([^"]+)">').match, headers=headers).data
+
+    patronBlock = r'tab-content(?P<block>.*?)serie-player'
+    patron = r'data.num..(?P<season>\d+)x(?P<episode>\d+)" data-title="(?P<title>[^"]+).*?data-link="(?P<url>http.*?)</li>'
+    
+    return locals()
+
+
+def search(item, texto):
+    support.info()
+
+    item.url = host + '/index.php?story=%s&do=search&subaction=search' % (texto)
+    item.contentType = 'tvshow'
+
+    try:
+        return peliculas(item)
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info(line)
+        return []
+
+
+def newest(categoria):
+    support.info()
+
+    itemlist = []
+    item = Item()
+    item.contentType = 'tvshow'
+    item.args = 'newest'
+    try:
+        item.url = "%s/aggiornamento-episodi/" % host
+        item.action = "peliculas"
+        itemlist = peliculas(item)
+        
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info("{0}".format(line))
+        return []
+
+    return itemlist
+
+def findvideos(item):
+    support.info()
+    itemlist = support.server(item, item.url)
+    return itemlist

channels/fastsubita.json

@@ -1,11 +0,0 @@
-{
-    "id": "fastsubita",
-    "name": "Fastsubita",
-    "language": ["sub-ita"],
-    "active": false,
-    "thumbnail": "fastsubita.png",
-    "banner": "fastsubita.png",
-    "categories": ["tvshow", "vos"],
-    "not_active": ["include_in_newest_peliculas", "include_in_newest_anime"],
-    "settings": []
-}

channels/fastsubita.py

@@ -1,214 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per fastsubita.py
-# ------------------------------------------------------------
-"""
-
-    Su questo canale, nella categoria 'Ricerca Globale'
-    non saranno presenti le voci 'Aggiungi alla Videoteca'
-    e 'Scarica Film'/'Scarica Serie', dunque,
-    la loro assenza, nel Test, NON dovrà essere segnalata come ERRORE.
-
-    Novità. Indicare in quale/i sezione/i è presente il canale:
-       - serie
-
-    Ulteriori info:
-        - SOLO SUB-ITA
-
-"""
-from core import support, httptools, scrapertools
-from core.item import Item
-from core.support import info
-from platformcode import config
-
-host = config.get_channel_url()
-headers = [['Referer', host]]
-
-
-@support.menu
-def mainlist(item):
-
-    Tvshow = [
-        ('Aggiornamenti', ['', 'peliculas', 'update']),
-        ('Cerca... {bold}{TV}', ['', 'search'])
-    ]
-
-    # search = ''
-
-    return locals()
-
-
-@support.scrape
-def peliculas(item):
-    support.info(item)
-    # support.dbg()
-    deflang = 'Sub-ITA'
-
-    # è una singola pagina con tutti gli episodi
-    if item.grouped and not support.scrapertools.find_single_match(item.url, '-[0-9]+x[0-9]+-'):
-        item.grouped = False
-        return episodios_args(item)
-
-    # ogni puntata è un articolo a se
-    if item.fulltitle:
-        item.url = host + '?s=' + item.fulltitle
-        actLike = 'episodios'
-
-    action = 'findvideos'
-    blacklist = ['']
-    if item.args == 'genres':
-        patronBlock = r'<h4 id="mctm1-.">'+item.fulltitle+'</h4>(?P<block>.+?)</div>'
-        patron = r'[^>]+>[^>]+>.+?href="(?P<url>[^"]+)[^>]>(?P<title>[^<]+)\s<'
-        action = 'episodios'
-    elif item.args == 'search':
-        group = True
-        patronBlock = r'</header>(?P<block>.*?)</main>'
-        patron = '(?:<img[^>]+src="(?P<thumb>[^"]+)".*?)?<a href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+?)(?:(?P<episode>\d+&#215;\d+|\d+×\d+)|\[[sS](?P<season>[0-9]+)[^]]+\])\s?(?:(?P<lang>\([a-zA-Z\s]+\)) (?:[Ss]\d+[Ee]\d+)?\s?(?:[&#\d;|.{3}]+)(?P<title2>[^”[<]+)(?:&#\d)?)?'
-    else:
-        # è una singola pagina con tutti gli episodi
-        if item.args != 'update' and not support.scrapertools.find_single_match(item.url, '-[0-9]+x[0-9]+-'):
-            return episodios_args(item)
-        patron = r'<div class="featured-thumb"> +<a href="(?P<url>[^"]+)" title="(?P<title>[^[]+)\[(?P<episode>\d+&#215;\d+)?'
-        patronBlock = r'<main id="main"[^>]+>(?P<block>.*?)<div id="secondary'
-
-    # def itemlistHook(itemlist):
-    #     from core import scraper
-    #     return scraper.sort_episode_list(itemlist)
-
-    patronNext = '<a class="next page-numbers" href="(.*?)">Successivi'
-
-    # debug = True
-    return locals()
-
-
-def episodios_args(item):
-    actLike = 'episodios'
-    # support.dbg()
-
-    deflang = 'Sub-ITA'
-    action = 'findvideos'
-    patron = '(?P<episode>\d+&#215;\d+|\d+[×.]+\d+)(?:\s?\((?P<lang>[a-zA-Z ]+)\))?(?:\s[Ss]\d+[Ee]+\d+)? +(?:“|&#8220;)(?P<title2>.*?)(?:”|&#8221;).*?(?P<other>.*?)(?:/>|<p)'
-    patronBlock = r'<main id="main" class="site-main" role="main">(?P<block>.*?)</main>'
-    patronNext = '<a class="next page-numbers" href="(.*?)">Successivi'
-
-    # debug = True
-    return locals()
-
-
-@support.scrape
-def episodios(item):
-    support.info(item)
-    return episodios_args(item)
-
-
-@support.scrape
-def genres(item):
-    support.info()
-    #support.dbg()
-
-    action = 'peliculas'
-    patronBlock = r'<div id="mcTagMapNav">(?P<block>.+?)</div>'
-    patron = r'<a href="(?P<url>[^"]+)">(?P<title>.+?)</a>'
-
-    def itemHook(item):
-        item.url = host+'/elenco-serie-tv/'
-        item.contentType = 'tvshow'
-        return item
-
-    #debug = True
-    return locals()
-
-
-def search(item, text):
-    support.info('search', item)
-    text = text.replace(' ', '+')
-    item.url = host + '?s=' + text
-    try:
-        item.args = 'search'
-        item.contentType = 'tvshow'
-        return peliculas(item)
-    # Se captura la excepcion, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            info('search log:', line)
-        return []
-
-
-def newest(categoria):
-    support.info('newest ->', categoria)
-    itemlist = []
-    item = Item()
-    if categoria == 'series':
-        try:
-            item.contentType = 'tvshow'
-            item.args = 'newest'
-            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():
-                support.info('newest log: ', line)
-            return []
-
-    return itemlist
-
-
-def findvideos(item):
-    support.info('findvideos ->', item)
-    patron = r'<a href="([^"]+)">'
-
-    itemlist = []
-    if item.other.startswith('http'):
-        resp = httptools.downloadpage(item.url, follow_redirects=False)
-        data = resp.headers.get("location", "") + '\n'
-    elif item.other:
-        html = support.match(item.other, patron=patron, headers=headers)
-        matches = html.matches
-        data = html.data
-        for scrapedurl in matches:
-            if 'is.gd' in scrapedurl:
-                resp = httptools.downloadpage(scrapedurl, follow_redirects=False)
-                data += resp.headers.get("location", "") + '\n'
-    elif not support.scrapertools.find_single_match(item.url, '-[0-9]+x[0-9]+-'):
-        return episodios(item)
-    else:
-        patronBlock = '<div class="entry-content">(?P<block>.*)<footer class="entry-footer">'
-        html = support.match(item, patron=patron, patronBlock=patronBlock, headers=headers)
-        matches = html.matches
-        data= html.data
-
-        if item.args != 'episodios':
-            item.infoLabels['mediatype'] = 'episode'
-        for scrapedurl in matches:
-            if 'is.gd' in scrapedurl:
-                resp = httptools.downloadpage(scrapedurl, follow_redirects=False)
-                data += resp.headers.get("location", "") + '\n'
-
-    itemlist += support.server(item, data)
-
-    # data = support.match(item.url).data
-    # patron = r'>Posted in <a href="https?://fastsubita.com/serietv/([^/]+)/(?:[^"]+)?"'
-    # series = scrapertools.find_single_match(data, patron)
-    # titles = support.typo(series.upper().replace('-', ' '), 'bold color kod')
-    # goseries = support.typo("Vai alla Serie:", ' bold color kod')
-    # itemlist.append(
-    #     item.clone(channel=item.channel,
-    #                # title=goseries + titles,
-    #                title=titles,
-    #                fulltitle=titles,
-    #                show=series,
-    #                contentType='tvshow',
-    #                contentSerieName=series,
-    #                url=host+"/serietv/"+series,
-    #                action='episodios',
-    #                contentTitle=titles,
-    #                plot = "Vai alla Serie " + titles + " con tutte le puntate",
-    #                ))
-
-    return itemlist

channels/film4k.json

@@ -1,11 +0,0 @@
-{
-	"id": "film4k",
-	"name": "Film4k",
-	"language": ["ita"],
-	"active": false,
-	"thumbnail": "film4k.png",
-	"banner": "film4k.png",
-	"categories": ["tvshow", "movie", "anime"],
-	"not_active": ["include_in_newest_peliculas", "include_in_newest_anime", "include_in_newest_series"],
-	"settings": []
-}

channels/film4k.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per film4k
-# ------------------------------------------------------------
-
-from core import support
-from platformcode import logger, config
-
-
-def findhost(url):
-    return support.httptools.downloadpage(url).url
-
-host = config.get_channel_url(findhost)
-
-
-@support.menu
-def mainlist(item):
-
-    film = ['movies',
-            ('Qualità', ['', 'menu', 'quality']),
-            ('Generi', ['movies', 'menu', 'genres']),
-            ('Anno', ['movies', 'menu', 'releases']),
-            ('Più popolari', ['trending/?get=movies', 'peliculas']),
-            ('Più votati', ['ratings/?get=movies', 'peliculas'])]
-    tvshow = ['/tvshows',
-              ('Più popolari', ['trending/?get=tv', 'peliculas']),
-              ('Più votati', ['ratings/?get=tv', 'peliculas'])]
-    return locals()
-
-
-def search(item, text):
-    logger.info('search', text)
-    item.url = item.url + "/?s=" + text
-    try:
-        return support.dooplay_search(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-
-def peliculas(item):
-    if 'anime' in item.url:
-        return support.dooplay_peliculas(item, True)
-    else:
-        return support.dooplay_peliculas(item, False)
-
-
-def episodios(item):
-    itemlist = support.dooplay_get_episodes(item)
-    return itemlist
-
-
-def findvideos(item):
-    itemlist = []
-    if item.contentType == 'episode':
-        linkHead = support.httptools.downloadpage(item.url, only_headers=True).headers['link']
-        epId = support.scrapertools.find_single_match(linkHead, r'\?p=([0-9]+)>')
-        for link in support.dooplay_get_links(item, host, paramList=[['tv', epId, 1, 'title', 'server']]):
-            itemlist.append(
-                item.clone(action="play", url=link['url']))
-    else:
-        for link, quality in support.match(item.url, patron="(" + host + """links/[^"]+).*?class="quality">([^<]+)""").matches:
-            srv = support.servertools.find_video_items(data=support.httptools.downloadpage(link).data)
-            for s in srv:
-                s.quality = quality
-            itemlist.extend(srv)
-    return support.server(item, itemlist=itemlist)
-
-
-@support.scrape
-def menu(item):
-    action = 'peliculas'
-    if item.args in ['genres','releases']:
-        patronBlock = r'<nav class="' + item.args + r'">(?P<block>.*?)</nav'
-        patronMenu= r'<a href="(?P<url>[^"]+)"[^>]*>(?P<title>[^<]+)<'
-    else:
-        patronBlock = r'class="main-header">(?P<block>.*?)headitems'
-        patronMenu = r'(?P<url>' + host + r'quality/[^/]+/\?post_type=movies)">(?P<title>[^<]+)'
-    return locals()

channels/filmigratis.json

@@ -1,35 +0,0 @@
-{
-  "id": "filmigratis",
-  "name": "Filmi Gratis",
-  "active": false,
-  "language": ["ita", "sub-ita"],
-  "thumbnail": "filmigratis.png",
-  "banner": "filmigratis.png",
-  "categories": ["movie","tvshow"],
-  "settings": [
-		{
-		  "id": "include_in_newest_peliculas",
-		  "type": "bool",
-		  "label": "@70727",
-		  "default": false,
-		  "enabled": false,
-		  "visible": false
-        },    
-		{
-		  "id": "include_in_newest_series",
-		  "type": "bool",
-		  "label": "@70727",
-		  "default": false,
-		  "enabled": false,
-		  "visible": false
-		},    
-		{
-		  "id": "include_in_newest_anime",
-		  "type": "bool",
-		  "label": "@70727",
-		  "default": false,
-		  "enabled": false,
-		  "visible": false
-		}
-    ]
-}

channels/filmigratis.py

@@ -1,156 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per Filmi Gratis
-# ------------------------------------------------------------
-"""
-    La voce "Al cinema" si riferisce ai titoli che scorrono nella home page
-
-    Problemi:
-        - Nessuno noto
-
-    Novità, il canale, è presente in:
-       - FILM
-"""
-import re
-
-from core import httptools, support
-from core.item import Item
-from platformcode import config
-
-host = config.get_channel_url()
-
-
-
-
-headers = [['Referer', host]]
-
-
-@support.menu
-def mainlist(item):
-    film = [
-        ('Al Cinema ', ['', 'peliculas', 'cinema']),
-        ('Categorie', ['', 'genres', 'genres']),
-    ]
-
-    tvshow = ['/serie/ALL',
-        ('Generi', ['', 'genres', 'genres'])
-    ]
-
-    search = ''
-    return locals()
-
-@support.scrape
-def peliculas(item):
-    support.info()
-
-    if item.args == 'search':
-        action = ''
-        patron = r'<div class="cnt">.*?src="([^"]+)"[^>]+>[^>]+>[^>]+>\s+(?P<title>.+?)(?:\[(?P<lang>Sub-ITA|SUB-ITA|SUB)\])?\s?(?:\[?(?P<quality>HD).+\]?)?\s?(?:\(?(?P<year>\d+)?\)?)?\s+<[^>]+>[^>]+>[^>]+>\s<a href="(?P<url>[^"]+)"[^<]+<'
-        patronBlock = r'<div class="container">(?P<block>.*?)</main>'
-    elif item.contentType == 'movie':
-        if not item.args:
-            # voce menu: Film
-            patronBlock = r'<h1>Film streaming ita in alta definizione</h1>(?P<block>.*?)<div class="content-sidebar">'
-            patron = r'<div class="timeline-right">[^>]+>\s<a href="(?P<url>.*?)".*?src="(?P<thumb>.*?)".*?<h3 class="timeline-post-title">(?:(?P<title>.+?)\s\[?(?P<lang>Sub-ITA)?\]?\s?\[?(?P<quality>HD)?\]?\s?\(?(?P<year>\d+)?\)?)<'
-            patronNext = r'<a class="page-link" href="([^"]+)">>'
-        elif item.args == 'cinema':
-            patronBlock = r'<div class="owl-carousel" id="postCarousel">(?P<block>.*?)<section class="main-content">'
-            patron = r'background-image: url\((?P<thumb>.*?)\).*?<h3.*?>(?:(?P<title>.+?)\s\[?(?P<lang>Sub-ITA)?\]?\s?\[?(?P<quality>HD)?\]?\s?\(?(?P<year>\d+)?\)?)<.+?<a.+?<a href="(?P<url>[^"]+)"[^>]+>'
-        elif item.args == 'genres':
-            # ci sono dei titoli dove ' viene sostituito con " da support
-            data = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data
-            data = re.sub('\n|\t', ' ', data)
-            patron = r'<div class="cnt">\s.*?src="([^"]+)".+?title="((?P<title>.+?)(?:[ ]\[(?P<lang>Sub-ITA|SUB-ITA)\])?(?:[ ]\[(?P<quality>.*?)\])?(?:[ ]\((?P<year>\d+)\))?)"\s*[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s+<a href="(?P<url>[^"]+)"'
-            patronBlock = r'<div class="container">(?P<block>.*?)</main>'
-            pagination = ''
-
-        patronNext = '<a class="page-link" href="([^"]+)">>>'
-    else:
-        action = 'episodios'
-        patron = r'<div class="cnt">\s.*?src="([^"]+)".+?title="((?P<title>.+?)(?:[ ]\[(?P<lang>Sub-ITA|SUB-ITA)\])?(?:[ ]\[(?P<quality>.*?)\])?(?:[ ]\((?P<year>\d+)\))?)"\s*[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s+<a href="(?P<url>[^"]+)"'
-##        if item.args == 'search':
-##            patron = r'<div class="cnt">.*?src="([^"]+)".+?[^>]+>[^>]+>[^>]+>\s+((?P<title>.+?)(?:[ ]\[(?P<lang>Sub-ITA|SUB-ITA)\])?(?:[ ]\[(?P<quality>.*?)\])?(?:[ ]\((?P<year>\d+)\))?)\s+<[^>]+>[^>]+>[^>]+>[ ]<a href="(?P<url>[^"]+)"'
-        patronBlock = r'<div class="container">(?P<block>.*?)</main>'
-
-    def itemHook(item):
-        if item.args == 'search':
-            if 'series' in item.url:
-                item.action = 'episodios'
-                item.contentType = 'tvshow'
-            else:
-                item.action = 'findvideos'
-                item.contentType = 'movie'
-        return item
-
-    #debug = True
-    return locals()
-
-
-@support.scrape
-def episodios(item):
-    support.info()
-
-    action = 'findvideos'
-    patronBlock = r'<div class="row">(?P<block>.*?)<section class="main-content">'
-    patron = r'href="(?P<url>.*?)">(?:.+?)?\s+S(?P<season>\d+)\s\-\sEP\s(?P<episode>\d+)[^<]+<'
-
-    return locals()
-
-@support.scrape
-def genres(item):
-    support.info()
-
-    if item.contentType == 'movie':
-        action = 'peliculas'
-        patron = r'<a href="(?P<url>.*?)">(?P<title>.*?)<'
-        patronBlock = r'CATEGORIES.*?<ul>(?P<block>.*?)</ul>'
-    else:
-        item.contentType = 'tvshow'
-        action = 'peliculas'
-        blacklist = ['Al-Cinema']
-        patron = r'<a href="(?P<url>.*?)">(?P<title>.*?)<'
-        patronBlock = r'class="material-button submenu-toggle"> SERIE TV.*?<ul>.*?</li>(?P<block>.*?)</ul>'
-
-    return locals()
-
-
-def search(item, text):
-    support.info('search', item)
-
-    text = text.replace(' ', '+')
-    item.url = host + '/search/?s=' + text
-    try:
-        item.args = 'search'
-        return peliculas(item)
-    # Se captura la excepcion, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            support.info('search log:', line)
-        return []
-
-def newest(categoria):
-    support.info('newest ->', categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == 'peliculas':
-            item.url = host
-            item.contentType = 'movie'
-            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():
-            support.info({0}.format(line))
-        return []
-
-    return itemlist
-
-def findvideos(item):
-    support.info()
-    return support.server(item)

channels/filmpertutti.json

@@ -5,6 +5,6 @@
   "language": ["ita", "sub-ita"],
   "thumbnail": "filmpertutti.png",
   "banner": "filmpertutti.png",
-  "categories": ["tvshow","movie"],
+  "categories": ["anime", "tvshow","movie"],
   "settings": []
 }

channels/filmpertutti.py

@@ -3,9 +3,9 @@
 # Canale per filmpertutti.py
 # ------------------------------------------------------------
 
-from core import httptools, support
+from core import httptools, support, scrapertools
 from core.item import Item
-from platformcode import config
+from platformcode import config, logger
 
 def findhost(url):
     page = httptools.downloadpage(url).data
@@ -15,17 +15,20 @@ def findhost(url):
 host = config.get_channel_url(findhost)
 headers = [['Referer', host]]
 
-
 @support.menu
 def mainlist(item):
 
-    film = ['/category/film/',
-            ('Generi', ['/category/film/', 'genres', 'lettersF'])
+    film = ['/category/film/feed/',
+            ('Film al cinema', ['/category/ora-al-cinema/feed/', 'peliculas']),
+            ('Generi', ['/', 'genres']),
+            ('Saghe', ['/', 'genres', 'saghe']),
            ]
 
-    tvshow = ['/category/serie-tv/',
-              ('Aggiornamenti', ['/aggiornamenti-serie-tv/', 'peliculas', 'newest']),
-              ('Per Lettera', ['/category/serie-tv/', 'genres', 'lettersS'])
+    tvshow = ['/category/serie-tv/feed/',
+             ]
+ 
+    anime = ['/category/anime/feed/',
+             ('SUB-ITA',['/category/anime-sub-ita/feed/', 'peliculas']),
              ]
 
     search = ''
@@ -34,94 +37,107 @@ def mainlist(item):
 
 @support.scrape
 def peliculas(item):
-    support.info()
-    # debug = True
-    #debugBlock = True
-    # support.dbg()
-
-    if item.args != 'newest':
-        patronBlock = r'<ul class="posts">(?P<block>.*)<\/ul>'
-        patron = r'<li><a href="(?P<url>[^"]+)" data-thumbnail="(?P<thumb>[^"]+)">.*?<div class="title[^"]*">(?P<title>.+?)(?:\[(?P<lang>Sub-ITA)\])?(?:[ ]\[?(?P<quality>[HD]+)?\])?(?:[ ]\((?P<year>\d+)\)?)?<\/div>'
-        patronNext = r'<a href="([^"]+)[^>]+>Pagina'
+    if not item.args == 'search': # pagination not works
+        if not item.nextpage:
+            item.page = 1
         else:
-        patronBlock = r'<ul class="posts">(?P<block>.*)<div class="clear[^"]*">'
-        patron = r'<li>\s?<a href="(?P<url>[^"]+)" data-thumbnail="(?P<thumb>[^"]+)">.*?<div class="title[^"]*">(?P<title>.+?)(?:\s\[(?P<quality>HD)\])?<\/div>\s*<div class="episode[^"]*"[^>]+>(?P<episode>[^<(]+)(?:\((?P<lang>[a-zA-Z\-]+)\))?'
+            item.page = item.nextpage
 
-    if item.args == 'search':
-        action = 'select'
-    elif item.contentType == 'tvshow':
-        action = 'episodios'
-    elif item.contentType == 'movie':
-        action ='findvideos'
+        if not item.parent_url:
+            item.parent_url = item.url
+
+        if item.args == 'genres':
+            action = 'check'
+
+        item.nextpage = item.page + 1
+        nextPageUrl = "{}/?paged={}".format(item.parent_url, item.nextpage)
+        patron= r'<item>\s<title>(?P<title>[^<]+?)\s*(\((?P<lang>Sub-[a-zA-Z]+)*\))?\s*(\[(?P<quality>[A-Z]*)\])?\s*(\((?P<year>[0-9]{4})\))?</title>.*?<link>(?P<url>.*?)</link>'
+        def fullItemlistHook(itemlist):
+            if len(itemlist) < 10:
+                return itemlist[:-1:]
             else:
-        action = 'select'
-
-    def itemHook(item):
-        item.title = item.title.replace(' - La Serie', '')
-        return item
+                return itemlist
+    else:
+        action = 'check'
+        patron= r'<article class=\"elementor-post.*?(<img .*?src=\"(?P<thumb>[^\"]+).*?)?<h3 class=\"elementor-post__title\".*?<a href=\"(?P<url>[^\"]+)\" >\s*(?P<title>[^<]+?)\s*(\((?P<lang>Sub-[a-zA-Z]+)*\))?\s*(\[(?P<quality>[A-Z]*)\])?\s*(\((?P<year>[0-9]{4})\))?\s+<'
 
     return locals()
 
-@support.scrape
 def episodios(item):
-    # debug = True
-    data = support.match(item.url, headers=headers).data
-    if 'accordion-item' in data:
-        patronBlock = r'<span class="season[^>]*>\d+[^>]+>[^>]+>[^>]+>[^>]+>\D*(?:STAGIONE|Stagione)[ -]+(?P<lang>[a-zA-Z\- ]+)[^<]*</span>(?P<block>.*?)<div id="(?:season|disqus)'
-        patron = r'<img src="(?P<thumb>[^"]+)">.*?<li class="season-no">(?P<season>\d+)(?:&#215;|×|x)(?P<episode>\d+)[^<0-9]*<\/li>(?P<data>.*?javascript:;">(?P<title>[^<]+).*?</tbody>)'
-    else:
-        patronBlock = r'(?:STAGIONE|Stagione)(?:<[^>]+>)?\s*(?:(?P<lang>[A-Za-z- ]+))?(?P<block>.*?)(?:&nbsp;|<strong>|<div class="addtoany)'
-        patron = r'(?:/>|p>)\s*(?P<season>\d+)(?:&#215;|×|x)(?P<episode>\d+)[^<]+(?P<data>.*?)(?:<br|</p)'
+    item.quality = ''
+    data = item.data if item.data else httptools.downloadpage(item.url).data
+    itemlist = []
 
-    def itemHook(i):
-        i.url = item.url
-        i.title.replace('&#215;','x')
-        if not i.contentLanguage:
-            i.contentLanguage = 'ITA'
-        return i
-    return locals()
+    for it in support.match(data, patron=[r'div class=\"single-season.*?(?P<id>season_[0-9]+).*?>Stagione:\s(?P<season>[0-9]+).*?(\s-\s(?P<lang>[a-zA-z]+?))?<']).matches:
+        block = support.match(data, patron = r'div id=\"'+ it[0] +'\".*?</div').match
+        for ep in support.match(block, patron=[r'<li><a href=\"(?P<url>[^\"]+).*?img\" src=\"(?P<thumb>[^\"]+).*?title\">(?P<episode>[0-9]+)\.\s+(?P<title>.*?)</span>']).matches:
+            itemlist.append(item.clone(contentType = 'episode',
+                                   action='findvideos',
+                                   thumb=ep[1],
+                                   episode=ep[2],
+                                   season=it[1],
+                                   contentSeason=it[1],
+                                   contentEpisodeNumber=ep[2],
+                                   title = support.format_longtitle(support.cleantitle(ep[3]), season = it[1], episode = ep[2], lang= it[3]),
+                                   url = scrapertools.unescape(ep[0]), data = '')
+                        )
 
+    if config.get_setting('episode_info') and not support.stackCheck(['add_tvshow', 'get_newest']):
+        support.tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    support.check_trakt(itemlist)
+    support.videolibrary(itemlist, item)
+    if (config.get_setting('downloadenabled')):    
+        support.download(itemlist, item)
+
+    return itemlist
 
 @support.scrape
 def genres(item):
-
-    if item.args == 'lettersF':
-        item.contentType = 'movie'
-    else:
-        item.contentType = 'tvshow'
-
     action = 'peliculas'
-    patronBlock = r'<select class="cats">(?P<block>.*?)<\/select>'
-    patronMenu = r'<option data-src="(?P<url>[^"]+)">(?P<title>[^<]+)<\/option>'
+    blacklist = ['Tutti i film',]
+    wantSaga = True if item.args == 'saghe' else False
+    item.args = 'genres'
 
+    patronBlock = r'<nav class="elementor-nav-menu--main (?P<block>.*?)</nav>'
+    patronMenu = r'<li class="menu-item.*?<a href="(?P<url>https:\/\/.*?)".*?>(?P<title>.*?)</a></li>'
+
+    def itemHook(item):
+        item.url = "{}/feed/".format(item.url)
+        return item
+
+    def itemlistHook(itemlist):
+        itl = []
+        for item in itemlist:
+            isSaga = item.fulltitle.startswith('Saga')
+
+            if len(item.fulltitle) != 3:
+                if (isSaga and wantSaga) or (not isSaga and not wantSaga):
+                    itl.append(item)
+        return itl
     return locals()
 
 
-def select(item):
-    support.info()
-    patron=r'class="taxonomy category"\s*><span property="name">([^>]+)</span></a><meta property="position" content="2">'
-    block = support.match(item.url, patron=patron,headers=headers).match
-    if block.lower() != 'film':
-        support.info('select = ### è una serie ###')
+def check(item):
+    item.data = httptools.downloadpage(item.url).data
+    if 'season-details' in item.data.lower():
         item.contentType = 'tvshow'
         return episodios(item)
     else:
-        support.info('select = ### è un movie ###')
         item.contentType = 'movie'
         return findvideos(item)
 
 
-def search(item, texto):
-    support.info()
-    item.url = host + "/?s=" + texto
+def search(item, text):
+    item.url = "{}/?{}".format(host, support.urlencode({'s': text}))
     item.args = 'search'
+
     try:
         return peliculas(item)
-    # Continua la ricerca in caso di errore
+
     except:
         import sys
         for line in sys.exc_info():
-            support.info("%s" % line)
+            logger.error("search except: %s" % line)
         return []
 
 
@@ -131,13 +147,13 @@ def newest(categoria):
     item = Item()
     try:
         if categoria == "peliculas":
-            item.url = host + "/category/film/"
+            item.url = host + "/category/film/feed/"
             item.action = "peliculas"
             item.extra = "movie"
             item.contentType = 'movie'
             itemlist = peliculas(item)
         else:
-            item.url = host + "/aggiornamenti-serie-tv/"
+            item.url = host + "/category/serie-tv/feed/"
             item.action = "peliculas"
             item.args = "newest"
             item.contentType = 'tvshow'
@@ -154,8 +170,16 @@ def newest(categoria):
 
 
 def findvideos(item):
+    video_url = item.url
+
     if item.contentType == 'movie':
-        data = support.match(item.url, patron=r'<a target="_blank" rel="nofollow" href="([^"]+)">').matches
-        return support.server(item, data=data, patronTag='Versione: <[^>]+>([^<]+)')
-    else:
-        return support.server(item, item.data)
+        video_url = support.match(item.url, patron=r'<a href="([^"]+)" rel="nofollow">').match
+
+    video_url = support.match(video_url, patron=r'<iframe src=\"(https://.*?)\"').match
+
+    if (video_url == ''):
+       return []
+
+    itemlist = [item.clone(action="play", url=srv) for srv in support.match(video_url, patron='<div class=\"megaButton\" meta-type=\"v\" meta-link=\"([^\"]+).*?(?=>)>').matches]
+    itemlist = support.server(item,itemlist=itemlist)
+    return itemlist

channels/filmstreaming.json

@@ -0,0 +1,10 @@
+{
+    "id": "filmstreaming",
+    "name": "Film Streaming",
+    "language": ["ita"],
+    "active": false,
+    "thumbnail": "filmstreaming.png",
+    "banner": "filmstreaming.png",
+    "categories": ["movie"],
+    "settings": []
+}

channels/filmstreaming.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per filmstreaming
+# ------------------------------------------------------------
+
+from core import support
+from core.item import Item
+from platformcode import config, logger
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+
+    film = ['/film',
+            ('Al Cinema', ['/cinema', 'peliculas']),
+            ('Ultimi Inseriti', ['', 'peliculas', 'last']),
+            ('Generi', ['', 'genres', 'genres']),
+            ('Anno', ['', 'genres', 'years'])]
+
+    return locals()
+
+
+def search(item, text):
+    logger.debug('search', text)
+    itemlist = []
+    text = text.replace(" ", "+")
+    item.url = '{}/index.php?do=search&subaction=search&story={}'.format(host, text)
+
+    try:
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("search except: %s" % line)
+        return []
+
+
+def newest(categoria):
+    logger.debug(categoria)
+
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == "peliculas":
+            item.url = host
+            item.action = "peliculas"
+            item.contentType = 'movie'
+            item.args = 'last'
+            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
+
+
+@support.scrape
+def peliculas(item):
+    # debug=True
+    if item.args == 'last':
+        patronBlock = r'inseriti:(?P<block>.*?)<div class="block-showmore'
+    patron = r'item-movie">[^>]+><a href="(?P<url>[^"]+)[^>]+><img data-src="(?P<thumb>[^"]+)(?:[^>]+>){6}(?P<title>[^<]+)(?:[^>]+>){4}(?P<year>\d+)?(?:[^>]+>){2}(?P<quality>[^<]+)'
+    # patron = r'item-movie">[^>]+><a href="(?P<url>[^"]+)[^>]+><img data-src="(?P<thumb>[^"]+)(?:[^>]+>){6}(?P<title>[^<]+)(?:[^>]+>){6}(?P<quality>[^<]+)'
+    patronNext = r'<a href="([^"]+)">&rarr'
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    action = "peliculas"
+    _type ={'years':'Anno', 'genres':'Categorie'}
+
+    patronBlock = _type[item.args] + r'(?:[^>]+>){4}(?P<block>.*?)</ul>'
+    patronMenu = '<li><a href="(?P<url>[^"]+)">(?P<title>.*?)</a>'
+
+    return locals()
+
+
+def findvideos(item):
+    urls = []
+    data = support.match(item.url).data
+    urls += support.match(data, patron=r'<span data-link="([^"]+)').matches
+    url = support.match(data, patron='<iframe [^>]+src="([^"]+)').match
+    if url:
+        urls.append(support.match(url).data)
+    return support.server(item, urls)

channels/guardaseriecam.json

@@ -2,7 +2,7 @@
     "id": "guardaseriecam",
     "name": "GuardaSerie Cam",
     "language": ["ita", "sub-ita"],
-    "active": false,
+    "active": true,
     "thumbnail": "https://raw.githubusercontent.com/32Dexter/DexterRepo/master/media/guardaserie_live.png",
     "banner": "",
     "categories": ["tvshow"],

channels/guardaseriecam.py

@@ -35,16 +35,17 @@ def list(item):
 
 @support.scrape
 def peliculas(item):
-    patron = r'<div class="mlnh-thumb"><a href="(?P<url>[^"]+).*?title="(?P<title>[^"]+).*?src="(?P<thumb>[^"]+).*?hdn">(?P<year>[0-9]{4})'
-    patronNext = 'pagenavi.*?<span>.</span>.*?<a href="([^"]+)'
+    # debug = True
+    patron = r'<div class="mlnh-thumb"><a href="(?P<url>[^"]+)[^>]+title="(?P<title>[^"]+).*?<img src="(?P<thumb>[^"]+).*?hdn">[^<]*(?P<year>[0-9]{4})'
+    patronNext = 'pagenavi.*?<a href="([^"]+)">\d+'
     action = 'episodios'
     return locals()
 
 
 @support.scrape
 def episodios(item):
-    patronBlock = r'<div class="tab-pane fade" id="season-(?P<season>.)"(?P<block>.*?)</div>'
-    patron = r'<a href="#" allowfullscreen data-link="(?P<url>[^"]+).*?title="(?P<title>[^"]+)(?P<lang>[sS][uU][bB]-?[iI][tT][aA])?\s*">(?P<episode>[^<]+)'
+    patronBlock = r'<div class="tab-pane fade" id="season-(?P<season>.)"(?P<block>.*?)</ul>\s*</div>'
+    patron = r'(?P<data><a href="#" allowfullscreen data-link="[^"]+.*?title="(?P<title>[^"]+)(?P<lang>[sS][uU][bB]-?[iI][tT][aA])?\s*">(?P<episode>[^<]+).*?</li>)'
     action = 'findvideos'
     # debug = True
     return locals()
@@ -67,4 +68,4 @@ def search(item, text):
 
 def findvideos(item):
     logger.debug()
-    return support.server(item, item.url)
+    return support.server(item, item.data)

channels/guardaserieclick.json

@@ -1,7 +1,7 @@
 {
     "id": "guardaserieclick",
     "name": "GuardaSerie.click",
-    "active": true,
+    "active": false,
     "language": ["ita", "vos"],
     "thumbnail": "guardaserieclick.png",
     "bannermenu": "guardaserieclick.png",

channels/guardaserieicu.json

@@ -2,7 +2,7 @@
     "id": "guardaserieicu",
     "name": "Guarda Serie Icu",
     "language": ["ita", "sub-ita"],
-    "active": true,
+    "active": false,
     "thumbnail": "https://raw.githubusercontent.com/32Dexter/DexterRepo/master/media/guarda_serie.jpg",
     "banner": "",
     "categories": ["tvshow"],

channels/guardaserieicu.py

@@ -18,27 +18,32 @@ host = config.get_channel_url()
 headers = [['Referer', host]]
 
 
-
-
 @support.menu
 def mainlist(item):
     tvshow = ['/serie']
     return locals()
 
+
 @support.scrape
 def peliculas(item):
-    patronBlock = r'movies-list movies-list-full(?P<block>.*?)footer>'
+    # debug = True
+    # patronBlock = r'movies-list movies-list-full(?P<block>.*?)footer>'
+    if item.args == 'search':
+        patron = r'<div data-movie-id[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>(?:\s*<span class="mli-quality">(?P<quality>[^>]+)</span>)?\s*<img src="(?P<thumbnail>[^"]+)[^>]+>[^>]+>[^>]+>(?P<title>[^<]+).*?jt-info[^>]+>[^:]+:\s*(?P<rating>[^<]+)[^>]+>[^>]+>[^>]+>(?P<year>\d*)[^>]+>[^>]+>[^>]+>(?P<duration>\d*).*?"f-desc">(?:\s*<p>(?P<plot>[^<]+))?'
+    else:
         patron = r'<div data-movie-id[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>[^>]+>[^>]+><img src="(?P<thumbnail>[^"]+)[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>[^<]+).*?jt-info[^>]+>[^:]+:\s*(?P<rating>[^<]+)[^>]+>[^>]+>[^>]+>(?P<year>\d*)[^>]+>[^>]+>[^>]+>(?P<duration>\d*)'
     patronNext = '<li class=.active.>.*?href=.(.*?).>'
     action = 'episodios'
     return locals()
 
+
 @support.scrape
 def episodios(item):
     patronBlock = r'<strong>Stagione (?P<season>[0-9]+)(?P<block>.*?)</div></div>'
     patron = r'<a href="(?P<url>[^"]+)">\s*Episodio\s*(?P<episode>[0-9]+)'
     return locals()
 
+
 def search(item, text):
     info(text)
     item.contentType = 'tvshow'
@@ -53,6 +58,7 @@ def search(item, text):
 
     return []
 
+
 def findvideos(item):
     support.info('findvideos', item)
     data = support.match(item, headers=headers, patron=r'div class="movieplay">([^>]+)').matches

channels/hd4me.py

@@ -25,7 +25,7 @@ def peliculas(item):
         pagination = ''
         patron = r'<a title="(?P<title>[^\(]+)\(\s*(?P<year>\d+)\)\s\D+(?P<quality>\d+p).{3}(?P<lang>[^ ]+).*?[^"]+"\s*href="(?P<url>[^"]+)'
     else:
-        patron = r'<a href="(?P<url>[^"]+)" (?:rel="?[0-9]+"?)? title="(?P<title>[^\(]+)(?!\()\s*\((?P<year>\d+)\)\s(?:[^\]]+\])?\D+(?P<quality>\d+p).{3}(?P<lang>[^ ]+).*?<img id="?cov"?.*?src="(?P<thumb>[^"]+)'
+        patron = r'<a href="(?P<url>[^"]+)" (?:rel="?[0-9]+"?)? title="(?P<title>[^"]+)(?!\()\s*\((?P<year>\d+)\)\s(?:[^\]]+\])?\D+(?P<quality>\d+p).{3}(?P<lang>[^ ]+).*?<img id="?cov"?.*?src="(?P<thumb>[^"]+)'
         patronNext = r'current(?:[^>]*>){2}\s*<a class="[^"]+"\s* href="([^"]+)'
     return locals()
 
@@ -57,5 +57,7 @@ def search(item, text):
 
 def findvideos(item):
     url = support.match(item, patron=r'<a class=["]?bot1["]? href="([^"]+)"').match
+    if not url.startswith('http'):
+        url = host + url
     url = support.httptools.downloadpage(url, followredirect=True).url
     return support.server(item, url)

channels/ilcorsaronero.py

@@ -3,83 +3,59 @@
 # Canale per ilcorsaronero
 # ------------------------------------------------------------
 
-from core import support
-
-# def findhost(url):
-#     data = support.httptools.downloadpage(url).data
-#     url = support.scrapertools.find_single_match(data, '<li><a href="([^"]+)')
-#     return url[:-1] if url.endswith('/') else url
+from core import support, httptools
 
 host = support.config.get_channel_url()
 support.info('HOST',host)
-# host = 'https://ilcorsaronero.xyz'
 headers = [['Referer', host]]
 
-
 @support.menu
 def mainlist(item):
 
     menu = [
-        ('BDRiP {film}', ['/categoria.php?active=0&category=1&order=data&by=DESC&page=', 'peliculas', [0, 'movie', True], 'undefined']),
-        ('Cerca BDRiP... {submenu} {film}', ['/torrent-ita/1/', 'search', ['search', 'movie', True], 'movie']),
-        ('DVD {film}', ['/categoria.php?active=0&category=20&order=data&by=DESC&page=', 'peliculas', [0, 'movie', True], 'undefined']),
-        ('Cerca DVD... {submenu} {film}', ['/torrent-ita/20/', 'search', ['search', 'movie', True], 'movie']),
-        ('Screener {film}', ['/categoria.php?active=0&category=19&order=data&by=DESC&page=', 'peliculas', [0, 'movie', True], 'undefined']),
-        ('Cerca Screener.. {submenu} {film}', ['/torrent-ita/19/', 'search', ['search', 'movie', True], 'movie']),
-        ('Serie TV', ['/categoria.php?active=0&category=15&order=data&by=DES&page=', 'peliculas', [0 , 'tvshow', True], 'tvshow']),
-        ('Cerca Serie TV.. {submenu}', ['/torrent-ita/15/', 'search', ['search', 'tvshow',True], 'tvshow']),
-        ('Anime', ['/categoria.php?active=0&category=5&order=data&by=DESC&page=', 'peliculas', [0, 'anime', True], 'tvshow']),
-        ('Cerca Anime.. {submenu}', ['/torrent-ita/5/', 'search', ['search', 'anime', True], 'tvshow']),
-        ('Musica', ['/categoria.php?active=0&category=2&order=data&by=DESC&page=', 'peliculas', [0, 'music', False], 'music']),
-        ('Cerca Musica.. {submenu}', ['/torrent-ita/2/', 'search', ['search', 'music', False], 'music']),
-        ('Audiolibri {musica}', ['/categoria.php?active=0&category=18&order=data&by=DESC&page=', 'peliculas', [0, 'music', False], 'music']),
-        ('Cerca Audiolibri.. {submenu}', ['/torrent-ita/18/', 'search', ['search', 'music', False], 'music']),
-        # mostrerebbe anche risultati non "multimediali" e allungherebbero inutilmente la ricerca globale
-        # ('Altro {film}', ['/categoria.php?active=0&category=4&order=data&by=DESC&page=', 'peliculas', [0, 'other', False]]),
-        # ('Cerca altro.. {submenu}', ['/torrent-ita/4/', 'search', ['search', 'other', False]]),
-        # ('Cerca Tutto... {color kod bold}', ['/argh.php?search=', 'search', ['search', 'all', False]])
+        ('Film {film}', ['/cat/film', 'peliculas', [0, 'movie', True], 'undefined']),
+        ('Serie TV', ['/cat/serie-tv', 'peliculas', [0 , 'tvshow', True], 'undefined']),
+        ('Animazione', ['/cat/animazione', 'peliculas', [0 , 'anime', True], 'undefined']),
+        ('Documentari', ['/cat/altro/documentari', 'peliculas', [0 , 'documentary', True], 'undefined']),
+        ('Programmi TV', ['/cat/altro/programmi-tv', 'peliculas', [0 , 'tvshow', True], 'tvshow']),
+        ('Video Musica', ['/cat/musica/video-musicali', 'peliculas', [0 , 'music', False], 'undefined']),
+        ('Videocorsi', ['/cat/altro/videocorsi', 'peliculas', [0 , 'music', False], 'undefined'])
     ]
+    search = ''
 
     return locals()
 
-
 @support.scrape
 def peliculas(item):
-    # debug = True
+    debug = False
+    action = 'findvideos'
     sceneTitle = item.args[2]    
-    if item.args[1] in ['tvshow', 'anime', 'music', 'other']:
-        patron = r'>[^"<]+'
-    else:
-        patron = r'>(?P<quality>[^"<]+)'
-    patron += '</td> <TD[^>]+><A class="tab" HREF="(?P<url>[^"]+)"\s*>(?P<title>[^<]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<size>[^<]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<seed>[^<]+)'
 
-    if 'search' not in item.args:
-        item.url += str(item.args[0])
-        def itemlistHook(itemlist):
-            args = item.args
-            args[0] += 1
-            support.nextPage(itemlist, item, next_page=item.url, function_or_level="peliculas")
-            # itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), args=args, thumbnail=support.thumb()))
-            return itemlist
+    def itemHook(item):
+        if not sceneTitle:
+            item.title = item.title.replace('_', ' ')
+            item.fulltitle = item.fulltitle.replace('_', ' ')
+        item.title = support.scrapertools.decodeHtmlentities(support.urlparse.unquote(item.title))
+
+        return item
+
+    patron = r'<a class="hover:underline line-clamp-1.*?href="(?P<url>[^"]+)"\s*>(?P<title>.*?)</a>[^>]+>[^>]+>[^>]+>(?P<seed>.*?)<'
+    patronNext = r'<a href="(?P<url>[^"]+)".*?Next</span>'
     return locals()
 
-
 def search(item, text):
-    support.info(item, text)
-    if 'all' in item.args:
-        item.url += text
-    else:
-        item.url += text + '.html'
+    item.url = "{}/search?{}".format(host, support.urlencode({'q': text}))
+    item.args = 'search'
+
     try:
         return peliculas(item)
-    # Cattura la eccezione così non interrompe la ricerca globle se il canale si rompe!
+
     except:
         import sys
         for line in sys.exc_info():
-            support.logger.error("search except: %s" % line)
+            logger.error("search except: %s" % line)
         return []
 
-
 def findvideos(item):
     if item.contentType == 'tvshow': item.contentType = 'episode'
     Videolibrary = True if 'movie' in item.args else False

channels/ilgeniodellostreaming.json

@@ -1,7 +1,7 @@
 {
     "id": "ilgeniodellostreaming",
     "name": "IlGenioDelloStreaming",
-    "active": true,
+    "active": false,
     "language": ["ita", "sub-ita"],
     "thumbnail": "ilgeniodellostreaming.png",
     "banner": "ilgeniodellostreaming.png",

channels/ilgeniodellostreaming_cam.json

@@ -1,7 +1,7 @@
 {
     "id": "ilgeniodellostreaming_cam",
     "name": "IlGenioDelloStreaming CAM",
-    "active": false,
+    "active": true,
     "language": ["ita"],
     "thumbnail": "ilgeniodellostreaming.png",
     "banner": "ilgeniodellostreaming.png",

channels/ilgeniodellostreaming_cam.py

@@ -25,6 +25,10 @@ def mainlist(item):
 
 @support.scrape
 def peliculas(item):
+    if item.text:
+        data = support.httptools.downloadpage(host + '/?s=' + item.text, post={'story': item.text, 'do': 'search', 'subaction': 'search'}).data
+        patron = '<img src="(?P<thumb>[^"]+)(?:[^>]+>){8}\s*<a href="(?P<url>[^"]+)[^>]+>(?P<title>[^<]+)(?:[^>]+>){4}IMDb\s(?P<rating>[^<]+)(?:[^>]+>){2}(?P<year>\d+)'
+    else:
         if item.args == 'sala':
             patronBlock = r'insala(?P<block>.*?)<header>'
             patron = r'<img src="(?P<thumb>[^"]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(?P<rating>[^<]+)[^>]+>[^>]+>(?P<quality>[^<]+)[^>]+>[^>]+>[^>]+>[^>]+><a href="(?P<url>[^"]+)">(?P<title>[^<]+)[^>]+>[^>]+>[^>]+>(?P<year>\d{4})'
@@ -55,8 +59,7 @@ def genres(item):
 
 def search(item, text):
     info(text)
-    text = text.replace(' ', '+')
-    item.url = host + "/search/" + text
+    item.text = text
     try:
         return peliculas(item)
     except:

channels/italiafilm.json

@@ -0,0 +1,11 @@
+{
+    "id": "italiafilm",
+    "name": "ItaliaFilm",
+    "language": ["ita", "sub-ita"],
+    "active": true,
+    "thumbnail": "italiafilm.png",
+    "banner": "",
+    "categories": ["movie"],
+    "not_active": ["include_in_newest"],
+    "settings": []
+}

channels/italiafilm.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'italifilm'
+# ------------------------------------------------------------
+
+from core import support, httptools, scrapertools, tmdb
+from platformcode import config, logger
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    menu = [
+            ('Film', ['/film/', 'list', 'film']),
+            ('Per Genere', ['', 'list', 'genere']),
+            ('Al Cinema', ['/cinema/', 'list', 'film']),
+            ('Sub-ITA', ['/sub-ita/', 'list', 'film']),
+            ('Top del Mese', ['/top-del-mese.html', 'list', 'film'])
+           ]
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def list(item):
+    actLike = 'peliculas'
+    if item.args == 'genere':
+        patronBlock = r'<ul class="sub-menu">(?P<block>.*?)</ul>'
+        patronMenu = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<]+)'
+        action = 'peliculas'
+    elif item.args == 'film':
+        patron = r'<div class="entry-summary.*?<a href="(?P<url>[^"]+)" title="(?P<title>[^\("]+)(?:\((?P<year>\d+)\))" class="[^"]+"><img class="lazyload" data-src="(?P<thumb>[^"]+)" alt="[^"]+".*?></a>'
+        patronNext = r'<a href="([^"]+)">(?:&rarr|→)'
+
+    return locals()
+
+def peliculas(item):
+    data = httptools.downloadpage(item.url).data
+    itemlist = []
+    for it in support.match(data, patron=[r'<div class="entry-summary.*?<a href="(?P<url>[^"]+)" title="(?P<title>[^"]+)(?:\((?P<year>\d+)\))" class="[^"]+"><img class="lazyload" data-src="(?P<thumb>[^"]+)" alt="[^"]+".*?></a>']).matches:
+        infoLabels = dict()
+        infoLabels['title'] = it[1]
+        infoLabels['mediatype'] = 'movie'
+        infoLabels['year'] = it[2]
+        itemlist.append(item.clone(action='findvideos', thumbnail = host + it[3].replace(' ','%20'), title = support.cleantitle(it[1]), url= it[0], infoLabels=infoLabels))
+
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    if item.args == 'search':
+        next = support.match(data, patron=['<a name="nextlink".*list_submit\((\d+)\);.*(?:&rarr|→)']).matches
+    else:
+        next = support.match(data, patron=['<a href="([^"]+)">(?:&rarr|→)']).matches
+
+    if next:
+        if item.args == 'search':
+            item.url = "{}/?{}".format(host, support.urlencode({"story": item.search_text,"do": "search","subaction": "search", "search_start": next[0]}))
+        else: 
+            item.url = next[0]
+        support.nextPage(itemlist = itemlist, item = item, next_page=item.url)
+
+    return itemlist
+
+
+def search(item, text):
+    item.args = 'search'
+    item.url = "{}/?{}".format(host, support.urlencode({"story": text,"do": "search","subaction": "search", "search_start": item.page}))
+    item.search_text = text
+    try:
+        return peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("search except: %s" % line)
+        return []
+
+#action di default
+def findvideos(item):
+
+    support.info('findvideos')
+    urls = []
+    data = support.match(item).data
+    matches = support.match(data, patron=r'<iframe.*?src="([^"]+)').matches
+
+    for m in matches:
+        if 'youtube' not in m and not m.endswith('.js'):
+            urls += support.match(m, patron=r'data-link="([^"]+)').matches
+    return support.server(item, urls)

channels/italiaserie.json

@@ -1,7 +1,7 @@
 {
     "id": "italiaserie",
     "name": "Italia Serie",
-    "active": true,
+    "active": false,
     "language": ["ita","sub-ita"],
     "thumbnail": "italiaserie.png",
     "bannermenu": "italiaserie.png",