Aggiornamento domini

* resolverdns: better exception handling

.github/ISSUE_TEMPLATE/canale-non-funzionante.md

@@ -0,0 +1,21 @@
+---
+name: Segnala Problemi ad un Canale
+about: Invio segnalazione per un canale non funzionante
+title: 'Inserisci il nome del canale'
+labels: Problema Canale
+assignees: ''
+
+---
+
+**Per poter scrivere o allegare file nella pagina devi:**
+    - cliccare sui [ ... ] in alto a destra della scheda 
+    - Edit. Da questo momento puoi scrivere e/o inviare file.
+
+
+Inserisci il nome del canale
+
+
+- Indica il tipo di problema riscontrato, sii il più esauriente possibile. Che azione ha portato all'errore (Es. non riesco ad aggiungere film nella videoteca, ne dal menu contestuale, ne dalla voce in fondo alla lista dei server)
+
+- Ottieni il log seguendo le istruzioni: https://telegra.ph/LOG-11-20 e invialo qui.
+

.github/ISSUE_TEMPLATE/server-non-funzionante.md

@@ -0,0 +1,19 @@
+---
+name: Segnala Problemi ad un Server
+about: Invio segnalazione per un server non funzionante
+title: 'Inserisci il nome del server'
+labels: Problema Server
+assignees: ''
+
+---
+
+**Per poter scrivere o allegare file nella pagina devi:**
+    - cliccare sui [ ... ] in alto a destra della scheda 
+    - Edit. Da questo momento puoi scrivere e/o inviare file.
+
+
+Inserisci il nome del server che indica problemi e se il problema è circoscritto ad un solo canale, indicalo
+
+
+- Allega il file di log nella sua completezza. Non cancellarne delle parti.
+

.github/ISSUE_TEMPLATE/test-canale.md

@@ -0,0 +1,286 @@
+---
+name: Test Canale
+about: Pagina per il test di un canale
+title: ''
+labels: Test Canale
+assignees: ''
+
+---
+Documento Template per il Test del canale
+
+Specifica, dove possibile, il tipo di problema che incontri, anche se non è presente alcuna voce per indicarlo.
+Se hai **suggerimenti/consigli/dubbi sul test**...Proponili e/o Chiedi! Scrivendo un commento a questo stesso issue, che trovi in fondo, dopo questa pagina.
+
+**Avvertenze:**
+
+Per il test dei canali **DEVI**:
+- utilizzare la versione **[BETA](https://kodiondemand.github.io/repo/KoD-installer-BETA.zip)** di KOD!
+- **ABILITARE IL DEBUG PER I LOG**
+
+**Per eseguire il test, ricordati di titolarlo con il nome del canale da te scelto, e salvare la pagina cliccando sul bottone verde in basso "SUBMIT NEW ISSUE"**
+
+**Ogni volta che hai un ERRORE con avviso di LOG. Puoi scegliere se:
+ ALLEGARE IMMEDIATAMENTE il file kodi.log nel punto, della pagina, in cui sei nel test
+ Allegare il file kodi.log a fine pagina.**
+
+**Per poter scrivere o allegare file nella pagina devi:**
+    - cliccare sui [ ... ] in alto a destra della scheda 
+    - Edit. Da questo momento puoi scrivere e/o inviare file.
+Dopodiché clicca sul bottone verde "Update comment" per continuare il test nel modo consueto o per terminarlo!
+
+Se hai problemi non previsti dal test, segnalali aggiungendoli in fondo al test.
+
+**SE VEDI I QUADRATINI MA NON RIESCI A CLICCARLI... DEVI CLICCARE SUL BOTTONE VERDE "SUBMIT NEW ISSUE"**
+
+***
+I file relativi al canale li trovi:
+- su browser:
+[Apre la pagina dei Canali](https://github.com/kodiondemand/addon/tree/master/channels)
+- sul device:
+[nella specifica cartella](https://github.com/kodiondemand/addon/wiki/Percorsi-sui-diversi-S.O.) , .kodi/addons/channels.
+Per aprirli non servono programmi particolari un semplice editor di testo è sufficiente.
+
+**Test N.1**: Controllo del file .json
+
+Occorrente: file .json
+
+**1. Indica la coerenza delle voci presenti in "language" con i contenuti presenti sul sito:**
+valori: ita, sub-ita (sub-ita)
+
+- [ ] coerenti
+- [ ] non coerenti
+
+Se non sono coerenti il test è FALLITO, continua comunque a revisionare il resto
+
+**2. Icone del canale**
+Controlla sia presente qualcosa, tra le " " di thumbnail e banner, e che le immagini appaiano su KoD
+
+**in thumbnail:**
+- [ ] Presente 
+- [ ] Assente
+
+**in banner:**
+- [ ] Presente 
+- [ ] Assente
+
+**3. Verifica la coerenza delle voci presenti in "categories" con i contenuti presenti sul sito:**
+
+Riepilogo voci:
+
+	movie, tvshow, anime, documentary, vos, adult
+
+(se il sito contiene film e serie, devono esserci sia movie che tvshow, se contiene solo film, solo movie)
+
+- [ ] Corrette
+- [ ] 1 o più Errata/e
+- [ ] Assenti - Non sono presenti voci in categories, in questo caso non puoi continuare il test.
+
+Se le voci sono: Assenti, dopo aver compilato la risposta, salva il test e **NON** proseguire.
+**TEST FALLITO**
+
+***
+
+**Test su KOD.**
+
+Entra in KOD -> Canali. Nella lista accedi al canale che stai testando.
+**N.B.**: Il nome del canale è il campo **name** nel file .json.
+
+**Test N.2: Pagina Canale**
+
+**1. Cerca o Cerca Film...**
+Cerca un titolo a caso in KOD e lo stesso titolo sul sito. Confronta i risultati.
+
+- [ ] OK
+- indica il tipo di problema
+
+**Sezione FILM (se il sito non ha film elimina questa parte)**
+
+**TestN.3: Pagina dei Titoli**
+*Test da effettuare mentre sei dentro un menu del canale (film, serietv, in corso ecc..)*.
+Voci nel menu contestuale di KOD. Posizionati su di un titolo e controlla se hai le seguenti voci, nel menu contestuale (tasto c o tenendo enter premuto):
+
+**1. Aggiungi Film in videoteca**
+
+- [ ] Si
+- [ ] No
+
+**2. Scarica Film (devi avere il download abilitato)**
+
+- [ ] Si
+- [ ] No
+
+**Fine test menu contestuale**
+
+**Fondo pagina dei titoli**
+
+**3. Paginazione, controlla ci sia la voce "Successivo" (se non c'è controlla sul sito se è presente)**
+
+- [ ] Sì
+- [ ] NO
+
+**Dentro un titolo
+
+**4. Entra nella pagina del titolo e verifica ci sia almeno 1 server:**
+
+- [ ] Si
+- [ ] No
+
+**5. Eventuali problemi riscontrati**
+- scrivi qui il problema/i 
+
+**Sezione Serie TV (se il sito non ha serietv elimina questa parte)**
+
+Test da effettuare mentre sei nella pagina dei titoli.
+Per ogni titolo verifica ci siano le voci nel menu contestuale.
+
+**1. Aggiungi Serie in videoteca**
+
+- [ ] Si
+- [ ] No
+
+**2. Scarica Stagione (devi avere il download abilitato)**
+
+- [ ] Si
+- [ ] No
+
+**3. Scarica Serie (devi avere il download abilitato)**
+
+- [ ] Si
+- [ ] No
+
+**4. Cerca o Cerca Serie...**
+Cerca un titolo a caso in KOD e lo stesso titolo sul sito. Confronta i risultati.
+
+- [ ] Ok
+- indica il tipo di problema
+
+**5. Entra nella pagina della serie,  verifica che come ultima voce ci sia "Aggiungi in videoteca":**
+
+- [ ] Si, appare
+- [ ] Non appare
+
+**6. Entra nella pagina dell'episodio, **NON** deve apparire la voce "Aggiungi in videoteca":**
+
+- [ ] Si, appare
+- [ ] Non appare
+
+**7. Eventuali problemi riscontrati**
+- scrivi qui il problema/i 
+
+**Sezione Anime (se il sito non ha anime elimina questa parte)**
+
+Test da effettuare mentre sei nella pagina dei titoli. Per ogni titolo verifica ci siano le voci nel menu contestuale.
+
+**1. Rinumerazione (se gli episodi non appaiono nella forma 1x01)**
+
+- [ ] Si
+- [ ] No
+
+**2. Aggiungi Serie in videoteca**
+
+- [ ] Si
+- [ ] No
+
+**3. Aggiungi 2-3 titoli in videoteca.**
+- [ ] Aggiunti correttamente
+- [Indica eventuali problemi] (copia-incolla per tutti i titoli con cui hai avuto il problema)
+
+- COPIA qui l'ERRORE dal LOG
+
+**4. Scarica Serie**
+
+- [ ] Si
+- [ ] No
+
+**5. Cerca o Cerca Serie...**
+Cerca un titolo a caso in KOD e lo stesso titolo sul sito. Confronta i risultati.
+
+- [ ] Ok
+- indica il tipo di problema
+
+**6. Entra nella pagina della serie, verifica che come ultima voce ci sia "Aggiungi in videoteca":**
+
+- [ ] Appare
+- [ ] Non appare
+
+**7. Entra nella pagina dell'episodio, NON ci deve essere la voce "Aggiungi in videoteca":**
+
+- [ ] Non appare
+- [ ] Appare
+
+**8. Eventuali problemi riscontrati**
+- scrivi qui il problema/i
+
+** TEST PER IL CONFRONTO TRA SITO E CANALE **
+
+**TestN.4: Pagina Sito - Menu Canale**
+
+Occorrente: Browser, KOD! e il file canale.py ( da browser o da file )
+Avviso:
+- Sul Browser disattiva eventuali componenti aggiuntivi che bloccano i JS (javascript), li riattivi alla fine del test.
+
+Entra in ogni menu e controlla che i risultati, delle prime 5-6 pagine, siano gli stessi che trovi sul sito, comprese le varie info (ita/sub-ita, qualità ecc..), inoltre entra, se ci sono, nei menu dei generi - anni - lettera, verifica che cliccando su una voce si visualizzino i titoli.
+
+  *Copia questa sezione per ogni voce che presenta problemi:*
+
+- [ ] Voce menu ( del canale dove riscontri errori)
+
+Titoli non corrispondenti:
+
+- [ ] Il totale dei Titoli è diverso da quello del sito. Alcuni Titoli non compaiono.
+- [ ] Appaiono titoli per pagine informative o link a siti esterni. Es: Avviso agli utenti.
+- [ ] La lingua, del titolo, è diversa da quella riportata dal sito
+- [ ] Non è indicato in 1 o più titoli che sono SUB-ITA
+- [ ] Cliccando su "Successivo" non si visualizzano titoli
+- [ ] Non è indicata la qualità: Hd-DVD/rip e altri, nonostante sul sito siano presenti
+
+- [ ] NO
+
+
+  *Fine Copia*
+
+  
+**Test.N5: Ricerca Globale**
+
+Per questo test ti consiglio di inserire come UNICO sito quello che stai testando, come canale incluso in: Ricerca Globale -> scegli i canali da includere
+Il test è già compilato con le spunte, dato che devi copiarlo solo in caso di errori. Togli la spunta dove funziona.
+Si consiglia di cercare almeno a fino 5 titoli. O perlomeno non fermarti al 1°.
+
+Cerca 5 FILM a tuo piacimento, se il titolo non esce controlla confrontando i risultati sul sito...:
+
+ *Copia questa sezione per ogni voce che presenta problemi*
+
+controlla ci siano queste voci se titolo è un FILM:
+
+- [ ] inserisci il titolo cercato che da problemi
+- [x] Aggiungi in videoteca
+- [x] Scarica Film
+
+  *Fine Copia*
+
+controlla ci siano queste voci se titolo è una SERIE/ANIME:  
+  
+  *Copia questa sezione per ogni voce che presenta problemi*
+
+controlla ci siano queste voci se titolo è un FILM:
+
+- [ ] inserisci il titolo cercato che da problemi
+- [x] Aggiungi in videoteca
+- [x] Scarica Serie
+- [x] Scarica Stagione
+
+- [ ] inserisci il titolo cercato che da problemi
+
+  *Fine Copia*
+  
+  
+Se il canale ha la parte Novità (questa stringa avvisa che NON è presente: "not_active": ["include_in_newest"]).
+
+**Test.N6: Novità.**
+Per questo test ti consiglio di inserire come UNICO sito quello che stai testando, come canale incluso in: Novità -> categoria (film, serie o altro )
+
+- [ ] Descrivere il problema
+
+Fine TEST!
+
+Grazie mille da parte di tutto il team KoD!

.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: Test Suite
+on:
+  workflow_dispatch:
+
+jobs:
+  tests:
+    runs-on: macos-latest
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4.3.0
+        with:
+          python-version: 3.9
+
+      - name: Run tests
+        run: |
+          ./tests/run.sh
+
+      - name: Commit & Push changes
+        uses: dmnemec/copy_file_to_another_repo_action@main
+        env:
+          API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }}
+        with:
+          source_file: 'reports'
+          destination_repo: 'kodiondemand/kodiondemand.github.io'
+          user_email: 'tests@kod.bot'
+          user_name: 'bot'
+          commit_message: 'Test suite'

.github/workflows/updateDomains.yml

@@ -0,0 +1,30 @@
+name: Update channel domains
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 17 * * *'
+
+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@v1
+      with:
+        python-version: 3.7
+
+    - name: Install dependencies
+      run: pip install requests
+
+    - name: Update domains
+      run: python tools/updateDomains.py
+
+    - name: Commit & Push changes
+      uses: actions-js/push@master
+      with:
+        message: "Aggiornamento domini"
+        branch: "master"
+        github_token: ${{ secrets.API_TOKEN_GITHUB }}

.github/workflows/updateDomainsStable.yml

@@ -0,0 +1,32 @@
+name: Update channel domains
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 17 * * *'
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    steps:
+    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+    - uses: actions/checkout@v2
+      with:
+        ref: stable
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3.7
+
+    - name: Install dependencies
+      run: pip install requests
+
+    - name: Update domains
+      run: python tools/updateDomains.py
+
+    - name: Commit & Push changes
+      uses: actions-js/push@master
+      with:
+        message: "Aggiornamento domini"
+        branch: "stable"
+        github_token: ${{ secrets.API_TOKEN_GITHUB }}

.gitignore

@@ -2,3 +2,12 @@
 *.pyc
 .DS_Store
 .idea/
+.directory
+custom_code.json
+last_commit.txt
+__pycache__/
+.vscode/settings.json
+bin/
+lib/abi
+tests/home/
+reports/

CONTRIBUTING.md

@@ -0,0 +1,55 @@
+Ciao, grazie per aver preso in considerazione di contribuire a questo progetto!<br>
+Ci sono molti modi per farlo, e per alcuni di essi non è necessario essere uno sviluppatore.
+
+Puoi ad esempio [segnalare i cambiamenti di struttura](#segnalare-i-cambiamenti-di-struttura) dei canali/server, [scrivere guide o registrare video-esempi](#scrivere-guide-o-registrare-video-esempi) su alcune funzionalità "avanzate", dare consigli su funzionalità nuove o per migliorare quelle già presenti. 
+
+# Segnalare i cambiamenti di struttura
+KoD, alla fine, non è altro che un browser che estrapola dai siti le info richieste secondo regole ben precise, basate sulla struttura dei siti.<br>
+I siti web cambiano, spesso, ciò che oggi funziona domani potrebbe non più funzionare, pertanto sono fondamentali le segnalazioni, ma esse per essere realmente utili devono:
+- contenere il file di log (lo potete generare andando in Aiuto - Segnala un problema e seguendo le istruzioni)
+- spiegare brevemente qual'è il problema e dove, ad esempio "cineblog da errore quando entro nella sezione Film", oppure "wstream non da nessun errore ma il video di fatto non parte"
+- essere replicabili, se si tratta di cose che accadono una volta ogni tanto puoi provare a segnalare lo stesso, sperando che nel log ci sia qualche indizio. Se non c'è, nada
+
+Prima di segnalare un problema assicurati che sia realmemte legato a KoD, sotto alcuni requisiti necessari:
+- avere l'ultima versione di KoD, per controllare vai qui e confronta il numero con quello presente nella sezione aiuto: https://github.com/kodiondemand/addon/commits/stable
+- avere una versione di kodi supportata, attualmente si tratta di 17.x e 18.x
+- verificare che il problema non dipenda dal sito stesso: se esce il messaggio 'Apri nel Browser': apri il tuo Browser e prova se li il film o serie tv funziona, senno apri il menù contestuale (tasto c) e clicca su "apri nel browser"
+
+Sei pregato di attenerti il più possibile a quanto descritto qua perchè un semplice "non funziona" fa solo perdere tempo.
+Puoi fare tutte le segnalazioni nella sezione [issues](https://github.com/kodiondemand/addon/issues), cliccando su "new issue" appariranno dei template che ti guideranno nel processo.
+Assicurati che qualcun'altro non abbia già effettuato la stessa segnalazione, nel caso avessi altro da aggiungere rispondi ad un issue già aperto piuttosto che farne uno nuovo.
+
+# Scrivere guide o registrare video-esempi
+Cerca di essere sintetico ma senza tralasciare le informazioni essenziali, una volta fatto mandalo pure sul [gruppo telegram](https://t.me/kodiondemand) taggando gli admin (@admin).<br>
+Verrà preso in considerazione il prima possibile ed eventualmente inserito nella [wiki](https://github.com/kodiondemand/addon/wiki) o verrà creato un comando richiamabile nel gruppo.
+
+# Consigli
+Effettuali sempre nella sezione [issues](https://github.com/kodiondemand/addon/issues), miraccomando descrivi e fai esempi pratici.<br>
+
+# Per sviluppatori
+
+Di seguito tutte le info su come prendere confidenza col codice e come contribuire
+
+## Da dove posso partire?
+Un buon punto di partenza è [la wiki](https://github.com/kodiondemand/addon/wiki), qui è presente un minimo di documentazione sul funzionamento di KoD.<br>
+Ti consigliamo vivamente, una volta compreso il funzionamento generale dell'addon (e prima di iniziare a sviluppare), di [forkare e clonare il repository](https://help.github.com/en/github/getting-started-with-github/fork-a-repo).<br>
+Questo perchè, oltre al fatto di poter iniziare a mandare modifiche sul tuo account github, l'utilizzo di git abilita la [dev mode](https://github.com/kodiondemand/addon/wiki/dev-mode), che ti sarà di aiuto nelle tue attività.
+
+## che cosa posso fare?
+Puoi provare a fixare un bug che hai riscontrato, aggiungere un canale/server che ti interessa ecc..
+Oppure puoi guardare nella sezione [Projects](https://github.com/kodiondemand/addon/projects) cosa è previsto e iniziare a svilupparlo!
+
+## ho fatto le modifiche che volevo, e ora?
+Pusha sul tuo fork le modifiche che hai fatto e manda una pull request. Se è la prima volta ecco qualche link che ti aiuterà:
+- http://makeapullrequest.com/
+- http://www.firsttimersonly.com/
+- [How to Contribute to an Open Source Project on GitHub](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github).
+
+Quando crei la pull request, ricordati di spiegare brevemente qual'è la modifica e perchè l'hai fatta.
+Quando avremo tempo revisioneremo le modifiche, potremmo anche segnalarti alcuni problemi, nel caso prenditi pure il tutto il tempo che vuoi per sistemare (non è necessaria un'altra pull, tutti i commit verranno riportati nella prima).<br>
+Quando sarà tutto a posto accetteremo la pull includendo le modifiche
+
+## Regole per le collaborazioni:
+- Se si riutilizza codice proveniente da altri addon è necessario citarne la fonte, per rispetto di chi ci ha lavorato, in caso contrario il pull request verrà respinto.
+- Ogni modifica o novità inviata dev'essere testata, può capitare che vi sia sfuggito qualche bug (è normale), ma l'invio di materiale senza preventivi controlli non è gradito.
+- I nuovi canali devono essere funzionanti e completi di tutte le feature, comprese videoteca ed autoplay, non verranno accettati finchè non lo saranno.

README.md

@@ -1,13 +1,13 @@
-# Alfa addon
-### Es un proyecto sin ánimo de lucro y con fines educativos, basado en el código open source de pelisalacarta-ce, que permite utilizar Kodi u otra plataforma compatible como "navegador" para ver vídeos alojados en paginas web.
+# Kodi On Demand
+### Un fork italiano di [Alfa](https://github.com/alfa-addon)
 
-### Este addon es totalmente gratuito por lo tanto esta prohibida su venta en solitario o como parte de software integrado en cualquier dispositivo, es absolutamente para uso educativo y personal.
+Installazione: https://kodiondemand.github.io/#download
 
-## Colaborar
-Si deseas colaborar con el proyecto eres bienvenido a hacerlo, pero ten en cuenta por favor estas pautas
+KoD, come Alfa, è sotto licenza GPL v3, pertanto siete liberi di utilizzare parte del codice, a patto di rispettare i termini di suddetta licenza, che si possono riassumere in: 
+ 
+- Il tuo addon deve essere rilasciando secondo la stessa licenza, ovvero essere open source (il fatto che lo zip sia visibile da chiunque non ha importanza, è necessario avere un repository git come questo) 
+- Aggiungere i crediti a tutto ciò che copiate/modificate, ad esempio aggiungendo un commento nel file in questione o, meglio, facendo un cherry-pick (in modo da preservarne lo storico)
 
-- Para colaborar con sus Pull Request se pide seguir unas reglas de estilo basadas en las de python PEP8. Esto se puede
-  hacer desde diferentes IDEs que lo traen integrado como pydev, pycharm o ninjaIDE, o extensiones que se pueden
-  agregar a por ejemplo sublime, atom.
+### Come contribuire o fare segnalazioni?
+Ti piace il progetto e vuoi dare una mano? Leggi [qui](https://github.com/kodiondemand/addon/blob/master/CONTRIBUTING.md)
 
-- Utilizar nombre de clases, métodos y variables en inglés para favorecer la comprensión de personas no hispano parlantes.

addon.xml

@@ -0,0 +1,43 @@
+<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" optional="true"/>
+    <import addon="metadata.tvshows.themoviedb.org" optional="true"/>
+    <!-- <import addon="metadata.tvdb.com"/> -->
+    
+  </requires>
+  <extension point="xbmc.python.pluginsource" library="default.py">
+    <provides>video</provides>
+  </extension>
+  <extension point="kodi.context.item">
+    <menu id="kodi.core.main">
+      <item library="contextmenu.py">
+        <label>90001</label>
+        <visible>!String.StartsWith(ListItem.FileNameAndPath, plugin://plugin.video.kod/) + [ String.IsEqual(ListItem.dbtype, tvshow) | String.IsEqual(ListItem.dbtype, movie) | String.IsEqual(ListItem.dbtype, season) | String.IsEqual(ListItem.dbtype, episode) ]</visible>
+      </item>
+    </menu>
+  </extension>
+  <extension point="xbmc.addon.metadata">
+    <summary lang="en">Kodi on Demand is a Kodi add-on to search and watch contents on the web.</summary>
+    <summary lang="it">Kodi on Demand è un addon di Kodi per cercare e guardare contenuti sul web.</summary>
+    <assets>
+      <icon>resources/media/logo.png</icon>
+      <fanart>resources/media/fanart.jpg</fanart>
+      <screenshot>resources/media/screenshot-1.png</screenshot>
+      <screenshot>resources/media/screenshot-2.png</screenshot>
+      <screenshot>resources/media/screenshot-3.png</screenshot>
+    </assets>
+      <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]
+    [COLOR yellow]Kodi © is a registered trademark of the XBMC Foundation. We are not connected to or in any other way affiliated with Kodi, Team Kodi, or the XBMC Foundation. Furthermore, any software, addons, or products offered by us will receive no support in official Kodi channels, including the Kodi forums and various social networks.[/COLOR]</disclaimer>
+    <platform>all</platform>
+    <license>GNU GPL v3</license>
+    <website>https://kodiondemand.github.io/</website>
+    <forum>https://t.me/kodiondemand</forum>
+    <source>https://github.com/kodiondemand/addon</source>
+  </extension>
+  <extension point="xbmc.service" library="service.py" start="login|startup">
+  </extension>
+</addon>

channels.json

@@ -0,0 +1,44 @@
+{
+    "direct": {
+        "altadefinizione01": "https://altadefinizione01.pet",
+        "animealtadefinizione": "https://www.animealtadefinizione.it",
+        "animeforce": "https://www.animeforce.it",
+        "animesaturn": "https://www.animesaturn.cx",
+        "animeunity": "https://www.animeunity.tv",
+        "animeworld": "https://www.animeworld.so",
+        "aniplay": "https://aniplay.co",
+        "casacinema": "https://casacinema.media",
+        "cb01anime": "https://cineblog01.red",
+        "cinemalibero": "https://cinemalibero.cafe",
+        "cinetecadibologna": "http://cinestore.cinetecadibologna.it",
+        "dinostreaming": "https://dinostreaming.it",
+        "discoveryplus": "https://www.discoveryplus.com",
+        "dreamsub": "https://www.animeworld.so",
+        "eurostreaming": "https://eurostreaming.diy",
+        "eurostreaming_actor": "https://eurostreaming.futbol",
+        "filmstreaming": "https://film-streaming-ita.cam",
+        "guardaseriecam": "https://guardaserie.kitchen",
+        "hd4me": "https://hd4me.net",
+        "ilcorsaronero": "https://ilcorsaronero.link",
+        "ilgeniodellostreaming_cam": "https://ilgeniodellostreaming.foo",
+        "italiafilm": "https://italia-film.biz",
+        "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",
+        "serietvu": "http://ww1.serietvu.live/?sub1=47fb879a-5325-11ee-94a7-cc35006f53d1",
+        "streamingcommunity": "https://streamingcommunity.buzz",
+        "streamingita": "https://streamingita.digital",
+        "tantifilm": "https://tantifilm.hair",
+        "toonitalia": "https://toonitalia.xyz"
+    },
+    "findhost": {
+        "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.json.txt

@@ -0,0 +1,107 @@
+Rev:0.2
+Update: 03-10-2019
+#####################
+
+Promemoria da cancellare pena la non visibilità del canale in KOD!!
+
+#####################
+
+
+le voci in settings sono state inserite per l'unico scopo
+di velocizzare la scrittura del file
+Vanno lasciate solo quelle voci il cui funzionamento sul 
+canale non vanno attivate.
+"not_active": ["include_in_newest"], VA INSERITO nei canali che NON hanno nessuna voce newest.
+Ovviamente va mantenuto tutto il codice di quell'id tra le {}
+se vanno cancellati tutti deve rimanere la voce:
+"settings": []
+##################### Cancellare fino a qui!
+{
+    "id": "nome del file .json",
+    "name": "Nome del canale visualizzato in KOD",
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "",
+    "banner": "",
+    "categories": ["movie", "tvshow", "anime", "vos", "documentary"],
+    "not_active": ["include_in_newest"],
+    "settings": [
+		{
+		  "id": "include_in_global_search",
+		  "type": "bool",
+		  "label": "@70728",
+		  "default": false,
+		  "enabled": false,
+		  "visible": false
+		},
+		{
+		  "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
+		},
+        {
+		  "id": "checklinks",
+		  "type": "bool",
+		  "label": "Verifica se i link esistono",
+		  "default": false,
+		  "enabled": false,
+		  "visible": false
+        },
+        {
+		  "id": "checklinks_number",
+		  "type": "list",
+		  "label": "Numero di link da verificare",
+		  "default": 2,
+		  "enabled": false,
+		  "visible": "eq(-1,false)",
+		  "lvalues": [ "3", "5", "10", "15", "20" ]
+        },
+        {
+		  "id": "filter_languages",
+		  "type": "list",
+		  "label": "@30019",
+		  "default": 0,
+		  "enabled": false,
+		  "visible": false,
+		  "lvalues": ["Non Filtrare"]
+        }
+  ],
+  
+  "renumber": [
+        {
+		  "id": "autorenumber", 
+		  "type": "bool", 
+		  "label": "@70712", 
+		  "default": false, 
+		  "enabled": false, 
+		  "visible": false
+        },
+        {
+		  "id": "autorenumber_mode",
+		  "type": "bool",
+		  "label": "@70688",
+		  "default": false,
+		  "enabled": false,
+          "visible": "eq(-1,false)"
+        }
+  ]
+}

channels/0example.py.txt

@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'idcanale nel json'
+# By: pincopallo!
+# Eventuali crediti se vuoi aggiungerli
+# ------------------------------------------------------------
+# Rev: 0.2
+# Update 12-10-2019
+# fix:
+# 1. aggiunto pagination e sistemate alcune voci
+# 2. modificato problemi in eccezioni
+# 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.
+# La maggior parte dei canali può essere scritta con il decoratore.
+# I commenti sono più un promemoria... che una vera e propria spiegazione!
+# Niente di più.
+# Ulteriori informazioni sono reperibili nel wiki:
+# https://github.com/kodiondemand/addon/wiki/decoratori
+ 
+"""
+    Questi sono commenti per i beta-tester.
+
+    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:
+       - Nessuna, film, serie, anime...
+
+    Avvisi:
+        - Eventuali avvisi per i tester
+
+    Ulteriori info:
+
+"""
+# CANCELLARE Ciò CHE NON SERVE per il canale, lascia il codice commentato ove occorre,
+# ma fare PULIZIA quando si è finito di testarlo
+
+# Qui gli import
+#import re
+
+# per l'uso dei decoratori, per i log, e funzioni per siti particolari
+from core import support
+
+# in caso di necessità
+#from core import scrapertools, httptools, servertools, tmdb
+from core.item import Item # per newest
+#from lib import unshortenit
+
+##### fine import
+
+# se il sito ha un link per ottenere l'url corretto in caso di oscuramenti
+# la funzione deve ritornare l'indirizzo corretto, verrà chiamata solo se necessario (link primario irraggiungibile)
+def findhost(url):
+    permUrl = httptools.downloadpage(url, follow_redirects=False).headers
+    if 'google' in permUrl['location']:
+        host = permUrl['location'].replace('https://www.google.it/search?q=site:', '')
+    else:
+        host = permUrl['location']
+    return host
+
+# se si usa findhost metti in channels.json l'url del sito che contiene sempre l'ultimo dominio
+host = config.get_channel_url(findhost)
+# se non si usa metti direttamente l'url finale in channels.json
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+### fine variabili
+
+#### Inizio delle def principali ###
+
+@support.menu
+def mainlist(item):
+    support.info(item)
+
+    # Ordine delle voci
+    # Voce FILM, puoi solo impostare l'url
+    film = ['', # url per la voce FILM, se possibile la pagina principale con le ultime novità
+        #Voce Menu,['url','action','args',contentType]
+        ('Al Cinema', ['', 'peliculas', '']),
+        ('Generi', ['', 'genres', 'genres']),
+        ('Per Lettera', ['', 'genres', 'letters']),
+        ('Anni', ['', 'genres', 'years']),
+        ('Qualità', ['', 'genres', 'quality']),
+        ('Mi sento fortunato', ['', 'genres', 'lucky']),
+        ('Popolari', ['', 'peliculas', '']),
+        ('Sub-ITA', ['', 'peliculas', ''])
+        ]
+
+    # Voce SERIE, puoi solo impostare l'url
+    tvshow = ['', # url per la voce Serie, se possibile la pagina con titoli di serie
+        #Voce Menu,['url','action','args',contentType]
+        ('Novità', ['', '', '']),
+        ('Per Lettera', ['', 'genres', 'letters']),
+        ('Per Genere', ['', 'genres', 'genres']),
+        ('Per anno', ['', 'genres', 'years'])
+        ]
+    # Voce ANIME, puoi solo impostare l'url
+    anime = ['', # url per la voce Anime, se possibile la pagina con titoli di anime
+        #Voce Menu,['url','action','args',contentType]
+        ('Novità', ['', '', '']),
+        ('In Corso',['', '', '', '']),
+        ('Ultimi Episodi',['', '', '', '']),
+        ('Ultime Serie',['', '', '', ''])
+        ]
+
+    """
+        Eventuali Menu per voci non contemplate!
+    """
+
+    # se questa voce non è presente il menu genera una voce
+    # search per ogni voce del menu. Es. Cerca Film...
+    search = '' # se alla funzione search non serve altro
+
+    # VOCE CHE APPARIRA' come prima voce nel menu di KOD!
+    # [Voce Menu,['url','action','args',contentType]
+    top = ([ '' ['', '', '', ''])
+
+    # Se vuoi creare un menu personalizzato o perchè gli altri non
+    # ti soddisfano
+    # [Voce Menu,['url','action','args',contentType]
+    nome = [( '' ['', '', '', ''])
+    return locals()
+
+
+# Legenda known_keys per i groups nei patron
+# known_keys = ['url', 'title', 'title2', 'season', 'episode', 'thumb', 'quality',
+#                'year', 'plot', 'duration', 'genere', 'rating', 'type', 'lang']
+# url = link relativo o assoluto alla pagina titolo film/serie
+# title = titolo Film/Serie/Anime/Altro
+# title2 = titolo dell'episodio Serie/Anime/Altro
+# season = stagione in formato numerico
+# episode = numero episodio, in formato numerico.
+# thumb = linkrealtivo o assoluto alla locandina Film/Serie/Anime/Altro
+# quality = qualità indicata del video
+# year = anno in formato numerico (4 cifre)
+# duration = durata del Film/Serie/Anime/Altro
+# genere = genere del Film/Serie/Anime/Altro. Es: avventura, commedia
+# rating = punteggio/voto in formato numerico
+# type = tipo del video. Es. movie per film o tvshow per le serie. Di solito sono discrimanti usati dal sito
+# lang = lingua del video. Es: ITA, Sub-ITA, Sub, SUB ITA.
+# AVVERTENZE: Se il titolo è trovato nella ricerca TMDB/TVDB/Altro allora le locandine e altre info non saranno quelle recuperate nel sito.!!!!
+@support.scrape
+def peliculas(item):
+    support.info(item)
+    #support.dbg() # decommentare per attivare web_pdb
+
+    action = ''
+    blacklist = ['']
+    patron = r''
+    patronBlock = r''
+    patronNext = ''
+    pagination = ''
+
+    #debug = True  # True per testare le regex sul sito
+    return locals()
+
+@support.scrape
+def episodios(item):
+    support.info(item)
+    #support.dbg()
+
+    action = ''
+    blacklist = ['']
+    patron = r''
+    patronBlock = r''
+    patronNext = ''
+    pagination = ''
+
+    #debug = True
+    return locals()
+
+# Questa def è utilizzata per generare i menu del canale
+# per genere, per anno, per lettera, per qualità ecc ecc
+@support.scrape
+def genres(item):
+    support.info(item)
+    #support.dbg()
+
+    action = ''
+    blacklist = ['']
+    patron = r''
+    patronBlock = r''
+    patronNext = ''
+    pagination = ''
+
+    #debug = True
+    return locals()
+
+############## Fine ordine obbligato
+## Def ulteriori
+
+# 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 check(item):
+    support.info('select --->', item)
+    #support.dbg()
+    data = httptools.downloadpage(item.url, headers=headers).data
+    # pulizia di data, in caso commentare le prossime 2 righe
+    data = re.sub('\n|\t', ' ', data)
+    data = re.sub(r'>\s+<', '> <', data)
+    block = scrapertools.find_single_match(data, r'')
+    if re.findall('', data, re.IGNORECASE):
+        support.info('select = ### è una serie ###')
+        return episodios(Item(channel=item.channel,
+                              title=item.title,
+                              fulltitle=item.fulltitle,
+                              url=item.url,
+                              args='serie',
+                              contentType='tvshow',
+                              #data1 = data decommentando portiamo data nella def senza doverla riscaricare
+                            ))
+
+############## Fondo Pagina
+# da adattare al canale
+def search(item, text):
+    support.info('search', item)
+    itemlist = []
+    text = text.replace(' ', '+')
+    item.url = host + '/index.php?do=search&story=%s&subaction=search' % (text)
+    # bisogna inserire item.contentType per la ricerca globale
+    # se il canale è solo film, si può omettere, altrimenti bisgona aggiungerlo e discriminare.
+    item.contentType = item.contentType
+    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():
+            info('search log:', line)
+        return []
+
+
+# da adattare al canale
+# inserire newest solo se il sito ha la pagina con le ultime novità/aggiunte
+# altrimenti NON inserirlo
+def newest(categoria):
+    support.info('newest ->', categoria)
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == 'peliculas':
+            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: ', {0}.format(line))
+        return []
+
+    return itemlist
+
+# da adattare...
+# consultare il wiki sia per support.server che ha vari parametri,
+# sia per i siti con hdpass
+#support.server(item, data='', itemlist=[], headers='', AutoPlay=True, CheckLinks=True)
+def findvideos(item):
+    support.info('findvideos ->', item)
+    return support.server(item, headers=headers)

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.json

@@ -0,0 +1,11 @@
+{
+  "id": "accuradio",
+  "name": "AccuRadio",
+  "active": true,
+  "language": ["*"],
+  "thumbnail": "accuradio.png",
+  "banner": "accuradio.png",
+  "categories": ["music"],
+  "not_active":["include_in_global_search"],
+  "settings" :[]
+}

channels/accuradio.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per accuradio
+# ------------------------------------------------------------
+
+import random
+from core import httptools, support
+from platformcode import logger
+
+host = 'https://www.accuradio.com'
+api_url = host + '/c/m/json/{}/'
+headers = [['Referer', host]]
+
+
+
+def mainlist(item):
+    itemlist = []
+    item.action = 'peliculas'
+    js = httptools.downloadpage(api_url.format('brands')).json
+    for it in js.get('features',[]):
+        itemlist.append(
+            item.clone(url= '{}/{}'.format(host,it.get('canonical_url','')),
+                       title=support.typo(it['name'],'italic') + support.typo(it.get('channels',''),'_ [] color kod')
+            ))
+    for it in js.get('brands',[]):
+        itemlist.append(
+            item.clone(url= '{}/{}'.format(host,it.get('canonical_url','')),
+                       title=support.typo(it['name'],'bullet bold') + support.typo(it.get('channels',''),'_ [] color kod')
+            ))
+
+    itemlist.append(item.clone(title=support.typo('Cerca...', 'bold color kod'), action='search', thumbnail=support.thumb('search')))
+    support.channel_config(item, itemlist)
+    return itemlist
+
+
+@support.scrape
+def peliculas(item):
+    # debug=True
+    action = 'playradio'
+    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()
+
+
+def playradio(item):
+    import xbmcgui, xbmc
+    items = httptools.downloadpage('{}/playlist/json/{}/?ando={}&rand={}'.format(host, item.id, item.oldid, random.random())).json
+    playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
+    playlist.clear()
+    for i in items:
+        if 'id' in i:
+            url = i['primary'] + i['fn'] + '.m4a'
+            title = i['title']
+            artist = i['track_artist']
+            album = i['album']['title']
+            year = i['album']['year']
+            thumb = 'https://www.accuradio.com/static/images/covers300' + i['album']['cdcover']
+            duration = i.get('duration',0)
+            info = {'duration':duration,
+                    'album':album,
+                    'artist':artist,
+                    'title':title,
+                    'year':year,
+                    'mediatype':'music'}
+            item = xbmcgui.ListItem(title, path=url)
+            item.setArt({'thumb':thumb, 'poster':thumb, 'icon':thumb})
+            item.setInfo('music',info)
+            playlist.add(url, item)
+    xbmc.Player().play(playlist)
+
+
+def search(item, text):
+    support.info(text)
+    item.url = host + '/search/' + text
+    itemlist = []
+    try:
+        data = support.match(item.url).data
+        artists = support.match(data, patronBlock=r'artistResults(.*?)</ul', patron=r'href="(?P<url>[^"]+)"\s*>(?P<title>[^<]+)').matches
+        if artists:
+            for url, artist in artists:
+                itemlist.append(item.clone(title=support.typo(artist,'bullet bold'), thumbnail=support.thumb('music'), url=host+url, action='peliculas'))
+        item.data = data
+        itemlist += peliculas(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("%s" % line)
+    return itemlist

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.json

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

channels/altadefinizione01.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per altadefinizione01
+# ------------------------------------------------------------
+"""
+    
+    Eccezioni note che non superano il test del canale:
+
+    Avvisi:
+        - L'url si prende da questo file.
+        - è presente nelle novità-> Film.
+
+    Ulteriori info:
+
+"""
+from core import scrapertools, httptools, support
+from core.item import Item
+from platformcode import config, logger
+
+
+# def findhost(url):
+#     data = httptools.downloadpage(url).data
+#     host = scrapertools.find_single_match(data, '<div class="elementor-button-wrapper"> <a href="([^"]+)"')
+#     return host
+
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+
+    film = [
+        ('Al Cinema', ['/cinema/', 'peliculas', 'pellicola']),
+        ('Ultimi Aggiornati-Aggiunti', ['','peliculas', 'update']),
+        ('Generi', ['', 'genres', 'genres']),
+        ('Lettera', ['/catalog/a/', 'genres', 'orderalf']),
+        ('Anni', ['', 'genres', 'years']),
+        ('Sub-ITA', ['/sub-ita/', 'peliculas', 'pellicola'])
+    ]
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    support.info('peliculas', item)
+
+##    deflang = 'ITA'
+    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>[^"]+)'
+        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})<' \
+                 '[^>]+>[^>]+>(?P<quality>[A-Z]+)[^>]+> <td class="mlnh-5">(?P<lang>.*?)</td>'
+    else:
+        patronBlock = r'<div class="cover_kapsul ml-mask">(?P<block>.*)<div class="page_nav">'
+
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    support.info('genres',item)
+    action = "peliculas"
+
+    blacklist = ['Altadefinizione01']
+    if item.args == 'genres':
+        patronBlock = r'<ul class="kategori_list">(?P<block>.*?)<div class="tab-pane fade" id="wtab2">'
+        patronMenu = '<li><a href="(?P<url>[^"]+)">(?P<title>.*?)</a>'
+    elif item.args == 'years':
+        patronBlock = r'<ul class="anno_list">(?P<block>.*?)</li> </ul> </div>'
+        patronMenu = '<li><a href="(?P<url>[^"]+)">(?P<title>.*?)</a>'
+    elif item.args == 'orderalf':
+        patronBlock = r'<div class="movies-letter">(?P<block>.*?)<div class="clearfix">'
+        patronMenu = '<a title=.*?href="(?P<url>[^"]+)"><span>(?P<title>.*?)</span>'
+
+    #debug = True
+    return locals()
+
+@support.scrape
+def orderalf(item):
+    support.info('orderalf',item)
+
+    action = 'findvideos'
+    patron = r'<td class="mlnh-thumb"><a href="(?P<url>[^"]+)".*?src="(?P<thumb>[^"]+)"'\
+             '.+?[^>]+>[^>]+ [^>]+[^>]+ [^>]+>(?P<title>[^<]+).*?[^>]+>(?P<year>\d{4})<'\
+             '[^>]+>[^>]+>(?P<quality>[A-Z]+)[^>]+> <td class="mlnh-5">(?P<lang>.*?)</td>'
+    patronNext = r'<span>[^<]+</span>[^<]+<a href="(.*?)">'
+
+    return locals()
+
+
+def search(item, text):
+    support.info(item, text)
+
+    
+    itemlist = []
+    text = text.replace(" ", "+")
+    item.url = host + "/index.php?do=search&story=%s&subaction=search" % (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():
+            logger.error("search except: %s" % line)
+        return []
+
+def newest(categoria):
+    support.info(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)
+    data = httptools.downloadpage(item.url).data
+    iframe = support.match(data, patron='src="(http[^"]+)" frameborder=\"0\" allow=\"accelerometer; autoplay;').match
+    if iframe:
+        item.url = iframe
+    return support.server(item)
+    
+    # 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/altadefinizioneclick.json

@@ -0,0 +1,11 @@
+{
+    "id": "altadefinizioneclick",
+    "name": "AltadefinizioneClick",
+    "active": false,
+    "language": ["ita","sub-ita"],
+    "thumbnail": "altadefinizioneclick.png",
+    "bannermenu": "altadefinizioneciclk.png",
+    "categories": ["tvshow","movie","vos"],
+    "not_active":["include_in_newest_series"],
+    "settings": []
+}

channels/altadefinizioneclick.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Altadefinizione Click
+# ----------------------------------------------------------
+
+from core import support
+from platformcode import config, logger
+
+def findhost(url):
+    return support.match(url, patron=r'<div class="elementor-button-wrapper">\s*<a href="([^"]+)"').match
+
+host = config.get_channel_url(findhost)
+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):
+    logger.debug(item)
+
+    film = ['/type/movie',
+            ('Generi', ['/type/movie', 'genres', 'genres']),
+            ('Anni', ['/type/movie', 'genres', 'year']),]
+
+    tvshow = ['/serie-tv/tvshow',
+              ('Generi', ['/serie-tv/tvshow', 'genres', 'genres']),
+              ('Anni', ['/serie-tv/tvshow', 'genres', 'year'])]
+
+    return locals()
+
+
+def search(item, texto):
+    logger.debug("search ", texto)
+
+    item.args = 'search'
+    item.url = host + "/search?s={}&f={}&page=1".format(texto, 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):
+    logger.debug(item)
+    data = support.httptools.downloadpage(item.url, cloudscraper=True).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':
+        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
+
+            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()
+
+
+@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

@@ -0,0 +1,37 @@
+{
+    "id": "altadefinizionecommunity",
+    "name": "Altadefinizione Community",
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "altadefinizionecommunity.png",
+    "banner": "",
+    "categories": ["movie", "tvshow", "vos"],
+    "not_active": ["include_in_newest"],
+    "settings": [
+        {
+      "default": "",
+      "enabled": true,
+      "id": "username",
+      "label": "username",
+      "type": "text",
+      "visible": true
+    },
+    {
+      "default": "",
+      "enabled": true,
+      "id": "password",
+      "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

@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Altadefinizione Community
+
+from core import support
+from lib.fakeMail import Gmailnator
+from platformcode import config, platformtools, logger
+from core import scrapertools, httptools
+
+
+def findhost(url):
+    return support.match(url, patron=r'<a href="([^"]+)/\w+">Accedi').match
+
+
+host = config.get_channel_url(findhost)
+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 = ['/type/movie',
+            ('Generi', ['/type/movie', 'genres', 'genres']),
+            ('Anni', ['/type/movie', 'genres', 'year']),]
+
+    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.data:
+        logger.info('Già loggato')
+    else:
+        logger.info('Login in corso')
+        post = {'_token': '',
+                'form_action':'login',
+                'email': config.get_setting('username', channel='altadefinizionecommunity'),
+                'password':config.get_setting('password', channel='altadefinizionecommunity')}
+
+        r = support.httptools.downloadpage(host + '/login', post=post, headers={'referer': host}, cloudscraper=True)
+        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.data
+
+
+def registerOrLogin():
+    if config.get_setting('username', channel='altadefinizionecommunity') and config.get_setting('password', channel='altadefinizionecommunity'):
+        if login():
+            return True
+
+    action = platformtools.dialog_yesno('AltadefinizioneCommunity',
+                                  'Questo server necessita di un account, ne hai già uno oppure vuoi tentare una registrazione automatica?',
+                                  yeslabel='Accedi', nolabel='Tenta registrazione', customlabel='Annulla')
+    if action == 1:  # accedi
+        from specials import setting
+        from core.item import Item
+        user_pre = config.get_setting('username', channel='altadefinizionecommunity')
+        password_pre = config.get_setting('password', channel='altadefinizionecommunity')
+        setting.channel_config(Item(config='altadefinizionecommunity'))
+        user_post = config.get_setting('username', channel='altadefinizionecommunity')
+        password_post = config.get_setting('password', channel='altadefinizionecommunity')
+
+        if user_pre != user_post or password_pre != password_post:
+            return registerOrLogin()
+        else:
+            return []
+    elif action == 0:  # tenta registrazione
+        import random
+        import string
+        logger.debug('Registrazione automatica in corso')
+        mailbox = Gmailnator()
+        randPsw = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(10))
+        logger.debug('email: ' + mailbox.address)
+        logger.debug('pass: ' + randPsw)
+        reg = platformtools.dialog_register(register_url, email=True, password=True, email_default=mailbox.address, password_default=randPsw)
+        if not reg:
+            return False
+        regPost = httptools.downloadpage(register_url, post={'email': reg['email'], 'password': reg['password']}, cloudscraper=True)
+
+        if regPost.url == register_url:
+            error = scrapertools.htmlclean(scrapertools.find_single_match(regPost.data, 'Impossibile proseguire.*?</div>'))
+            error = scrapertools.unescape(scrapertools.re.sub('\n\s+', ' ', error))
+            platformtools.dialog_ok('AltadefinizioneCommunity', error)
+            return False
+        if reg['email'] == mailbox.address:
+            if "L'indirizzo email risulta già registrato" in regPost.data:
+                # httptools.downloadpage(baseUrl + '/forgotPassword', post={'email': reg['email']})
+                platformtools.dialog_ok('AltadefinizioneCommunity', 'Indirizzo mail già utilizzato')
+                return False
+            mail = mailbox.waitForMail()
+            if mail:
+                checkUrl = scrapertools.find_single_match(mail.body, '<a href="([^"]+)[^>]+>Verifica').replace(r'\/', '/')
+                logger.debug('CheckURL: ' + checkUrl)
+                httptools.downloadpage(checkUrl, cloudscraper=True)
+                config.set_setting('username', mailbox.address, channel='altadefinizionecommunity')
+                config.set_setting('password', randPsw, channel='altadefinizionecommunity')
+                platformtools.dialog_ok('AltadefinizioneCommunity',
+                                        'Registrato automaticamente con queste credenziali:\nemail:' + mailbox.address + '\npass: ' + randPsw)
+            else:
+                platformtools.dialog_ok('AltadefinizioneCommunity', 'Impossibile registrarsi automaticamente')
+                return False
+        else:
+            platformtools.dialog_ok('AltadefinizioneCommunity', 'Hai modificato la mail quindi KoD non sarà in grado di effettuare la verifica in autonomia, apri la casella ' + reg['email']
+                                    + ' e clicca sul link. Premi ok quando fatto')
+        logger.debug('Registrazione completata')
+    else:
+        return False
+
+    return True

channels/animealtadefinizione.json

@@ -0,0 +1,21 @@
+{
+    "id": "animealtadefinizione",
+    "name": "AnimealtAdefinizione",
+    "active": false,
+    "language": ["ita", "sub-ita"],
+    "thumbnail": "animealtadefinizione.png",
+    "banner": "animealtadefinizione.png",
+    "categories": ["anime", "sub-ita"],
+    "default_off": ["include_in_newest"],
+    "settings": [
+        {
+            "id": "perpage",
+            "type": "list",
+            "label": "Elementi per pagina",
+            "default": 3,
+            "enabled": true,
+            "visible": true,
+            "lvalues": ["20","30","40","50","60","70","80","90","100"]
+        }
+    ]
+}

channels/animealtadefinizione.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per animealtadefinizione
+# ----------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+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>[^"]+)"[^>]+>\s*<img[^>]+/Streaming'
+
+
+@support.menu
+def mainlist(item):
+    anime=['/anime/',
+           ('Tipo',['', 'menu', 'Anime']),
+           ('Anno',['', 'menu', 'Anno']),
+           ('Genere', ['', 'menu','Genere']),
+           ('Ultimi Episodi',['', 'peliculas', 'last'])]
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    action = 'peliculas'
+    patronBlock= r'<a href="' + host + r'/category/' + item.args.lower() + r'/">' + item.args + r'</a>\s*<ul class="sub-menu">(?P<block>.*?)</ul>'
+    patronMenu = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)<'
+    return locals()
+
+
+def search(item, texto):
+    support.info(texto)
+    item.search = 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 []
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.url = host
+            item.args = "last"
+            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 []
+
+
+@support.scrape
+def peliculas(item):
+    if '/movie/' in item.url:
+        item.contentType = 'movie'
+        action='findvideos'
+    elif item.args == 'last':
+        item.contentType = 'episode'
+        action='episodios'
+    else:
+        item.contentType = 'tvshow'
+        action='episodios'
+    if item.search:
+        query = 's'
+        searchtext = item.search
+    else:
+        query='category_name'
+        searchtext = item.url.split('/')[-2]
+    if not item.pag: item.pag = 1
+    # debug = True
+    anime = True
+    data = support.match(host + '/wp-admin/admin-ajax.php', post='action=itajax-sort&loop=main+loop&location=&thumbnail=1&rating=1sorter=recent&columns=4&numarticles='+perpage+'&paginated='+str(item.pag)+'&currentquery%5B'+query+'%5D='+searchtext).data.replace('\\','')
+    patron = r'<a href="(?P<url>[^"]+)"><img width="[^"]+" height="[^"]+" src="(?P<thumb>[^"]+)" class="[^"]+" alt="" title="(?P<title>[^"]+?)\s+(?P<type>Movie)?\s*(?P<lang>Sub Ita|Ita)?\s*[sS]treaming'
+    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 ]
+        if len(itemlist) == int(perpage):
+            item.pag += 1
+            itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), action='peliculas'))
+        return itemlist
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    anime = True
+    # debug = True
+    pagination = int(perpage)
+    patron = epPatron
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    if item.contentType == 'movie':
+        matches = support.match(item, patron=epPatron).matches
+        for title, url in matches:
+            # support.dbg()
+            get_video_list(item, url, title, itemlist)
+    else:
+        get_video_list(item, item.url, support.config.get_localized_string(30137), itemlist)
+    return support.server(item, itemlist=itemlist)
+
+
+def get_video_list(item, url, title, itemlist):
+    if 'vvvvid' in url:
+        itemlist.append(item.clone(title='VVVVID', url=url, server='vvvvid', action='play'))
+    else:
+        from requests import get
+        if not url.startswith('http'): url = host + url
+
+        url = support.match(get(url).url, string=True, patron=r'file=([^$]+)').match
+        if 'http' not in url: url = 'http://' + url
+        itemlist.append(item.clone(title=title, url=url, server='directo', action='play'))
+
+    return itemlist

channels/animeforce.json

@@ -0,0 +1,60 @@
+{
+	"id": "animeforce",
+	"name": "AnimeForce",
+	"language": ["ita"],
+	"active": false,
+	"thumbnail": "animeforce.png",
+	"banner": "animeforce.png",
+	"categories": ["anime"],
+	"settings": [
+        {
+            "id": "include_in_global_search",
+            "type": "bool",
+            "label": "Includi in Ricerca Globale",
+            "default": false,
+            "enabled": false,
+            "visible": true
+        },
+        {
+            "id": "include_in_newest_anime",
+            "type": "bool",
+            "label": "Includi in Novità - Anime",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "checklinks",
+            "type": "bool",
+            "label": "Verifica se i link esistono",
+            "default": false,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "checklinks_number",
+            "type": "list",
+            "label": "Numero de link da verificare",
+            "default": 1,
+            "enabled": true,
+            "visible": "eq(-1,true)",
+            "lvalues": [ "1", "3", "5", "10" ]
+        },
+        {
+            "id": "autorenumber", 
+            "type": "bool", 
+            "label": "@70712", 
+            "default": false, 
+            "enabled": true, 
+            "visible": true
+        },
+        {
+            "id": "autorenumber_mode",
+            "type": "bool",
+            "label": "@70688",
+            "default": false,
+            "enabled": true,
+            "visible": "eq(-1,true)"
+        }
+	  ]
+}

channels/animeforce.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per AnimeForce
+# ------------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    anime = ['/anime',
+             ('In Corso',['/anime/anime-status/in-corso/', 'peliculas', 'status']),
+             ('Completi',['/anime/anime-status/completo/', 'peliculas', 'status']),
+             ('Genere',['/anime', 'submenu', 'genre']),
+             ('Anno',['/anime', 'submenu', 'anime-year']),
+             ('Tipologia',['/anime', 'submenu', 'anime-type']),
+             ('Stagione',['/anime', 'submenu', 'anime-season']),
+             ('Ultime Serie',['/category/anime/articoli-principali/','peliculas','last'])
+            ]
+    return locals()
+
+
+@support.scrape
+def submenu(item):
+    action = 'peliculas'
+    patronBlock = r'data-taxonomy="' + item.args + r'"(?P<block>.*?)</select'
+    patronMenu = r'<option class="level-\d+ (?P<url>[^"]+)"[^>]+>(?P<t>[^(]+)[^\(]+\((?P<num>\d+)'
+    def itemHook(item):
+        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()
+
+
+def newest(categoria):
+    support.info(categoria)
+    itemlist = []
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.contentType = 'tvshow'
+            item.url = host
+            item.args = 'newest'
+            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 []
+
+    return itemlist
+
+def search(item, text):
+    support.info('search',text)
+    item.search = text
+    item.url = host + '/lista-anime/'
+    item.contentType = 'tvshow'
+    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 peliculas(item):
+    search = item.search
+    anime = True
+    action = 'check'
+
+    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')
+            item.contentLanguage = 'Sub-ITA'
+        return item
+
+    return locals()
+
+
+def check(item):
+    m = support.match(item, headers=headers, patron=r'Tipologia[^>]+>\s*<a href="([^"]+)"')
+    item.data = m.data
+    if 'movie' in m.match:
+        item.contentType = 'movie'
+        return findvideos(item)
+    else:
+        return episodios(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>[^"]+)"[^>]+>(?P<episode>\d+)'
+    else:
+        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
+        elif item.url.startswith('/'): item.url= 'https:/' + item.url
+        return item
+    action = 'findvideos'
+    return locals()
+
+
+def findvideos(item):
+    support.info(item)
+    itemlist = []
+    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 = item.url
+
+    # 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 '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'))
+
+    return support.server(item, itemlist=itemlist)

channels/animesaturn.json

@@ -0,0 +1,10 @@
+{
+    "id": "animesaturn",
+    "name": "AnimeSaturn",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "animesaturn.png",
+    "banner": "animesaturn.png",
+    "categories": ["anime"],
+    "settings": []
+}

channels/animesaturn.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per AnimeSaturn
+# ----------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+__channel__ = 'animesaturn'
+cookie = support.config.get_setting('cookie', __channel__)
+headers = {'X-Requested-With': 'XMLHttpRequest', 'Cookie': cookie}
+
+
+def get_cookie(data):
+    global cookie, headers
+    cookie = support.match(data, patron=r'document.cookie="([^\s]+)').match
+    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:
+        get_cookie(data)
+        data = get_data(item)
+    return data
+
+
+@support.menu
+def mainlist(item):
+
+    anime = ['/animelist?load_all=1&d=1',
+             ('ITA',['', 'submenu', '/filter?language%5B0%5D=1']),
+             ('SUB-ITA',['', 'submenu', '/filter?language%5B0%5D=0']),
+             ('Più Votati',['/toplist','menu', 'top']),
+             ('In Corso',['/animeincorso','peliculas','incorso']),
+             ('Ultimi Episodi',['/fetch_pages.php?request=episodes&d=1','peliculas','updated'])]
+
+    return locals()
+
+
+def search(item, texto):
+    support.info(texto)
+    item.url = host + '/animelist?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.logger.error("%s" % line)
+        return []
+
+
+def newest(categoria):
+    support.info()
+    itemlist = []
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.url = host + '/fetch_pages.php?request=episodes&d=1'
+            item.args = "updated"
+            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 []
+
+    return itemlist
+
+
+@support.scrape
+def submenu(item):
+    data = 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):
+        itemlist.insert(0, item.clone(title=support.typo('Tutti','bold'), url=item.url + item.args, action='peliculas'))
+        return itemlist[:-1]
+    return locals()
+
+
+def filter(item):
+    itemlist = []
+    matches = support.match(item.data if item.data else item.url, patron=r'<option value="(?P<value>[^"]+)"[^>]*>(?P<title>[^<]+)').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)
+    return itemlist
+
+
+@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
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    anime = True
+
+    deflang= 'Sub-ITA'
+    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
+
+    if item.args == 'top':
+        data = item.other
+        patron = r'light">(?P<title2>[^<]+)</div>\s*(?P<title>[^<]+)[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)">(?:<a[^>]+>|\s*)<img.*?src="(?P<thumb>[^"]+)"'
+    else:
+        data = support.match(item, post=post, headers=headers).data
+        if item.args == 'updated':
+            page = support.match(data, patron=r'data-page="(\d+)" title="Next">').match
+            patron = r'<a href="(?P<url>[^"]+)" title="(?P<title>[^"(]+)(?:\s*\((?P<year>\d+)\))?(?:\s*\((?P<lang>[A-Za-z-]+)\))?">\s*<img src="(?P<thumb>[^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s\s*(?P<type>[^\s]+)\s*(?P<episode>\d+)'
+            typeContentDict = {'Movie':'movie', 'Episodio':'episode'} #item.contentType='episode'
+            action = 'findvideos'
+            def itemlistHook(itemlist):
+                if page:
+                    itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'),page= page, thumbnail=support.thumb()))
+                return itemlist
+        elif 'filter' in item.args:
+            page = support.match(data, patron=r'totalPages:\s*(\d+)').match
+            patron = r'<a href="(?P<url>[^"]+)" title="(?P<title>[^"(]+)(?:\s*\((?P<year>\d+)\))?(?:\s*\((?P<lang>[A-Za-z-]+)\))?">\s*<img src="(?P<thumb>[^"]+)"'
+            def itemlistHook(itemlist):
+                if item.nextpage: item.nextpage += 1
+                else: item.nextpage = 2
+                if page and item.nextpage < int(page):
+                    itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), url= '{}&page={}'.format(item.url, item.nextpage), infoLabels={}, thumbnail=support.thumb()))
+                return itemlist
+
+        else:
+            # 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:
+                # debug=True
+                patron = r'<img src="(?P<thumb>[^"]+)" alt="(?P<title>[^"\(]+)(?:\((?P<lang>[Ii][Tt][Aa])\))?(?:\s*\((?P<year>\d+)\))?[^"]*"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*<a class="[^"]+" href="(?P<url>[^"]+)">[^>]+>[^>]+>[^>]+>\s*<p[^>]+>(?:(?P<plot>[^<]+))?<'
+
+    return locals()
+
+
+def check(item):
+    movie = support.match(item, patron=r'Episodi:</b> (\d*) Movie')
+    if movie.match:
+        episodes = episodios(item)
+        if len(episodes) > 0:
+            it = episodes[0].clone(contentType = 'movie', contentTitle=item.fulltitle, contentSerieName='')
+        return findvideos(it)
+    else:
+        item.contentType = 'tvshow'
+        return episodios(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>[^\d<]+(?P<episode>\d+))\s*</a>'
+    return locals()
+
+
+def findvideos(item):
+    support.info()
+    itemlist = []
+    links = []
+
+    main_url = support.match(item, patron=r'<a href="([^"]+)">[^>]+>[^>]+>G').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'))
+    for url in urls:
+        link = support.match(url, patron=r'<a href="([^"]+)"[^>]+><button', headers=headers).match
+        if link:
+            links.append(link)
+    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:[^"]+)"([^"]+)').match
+    return[item]

channels/animeunity.json

@@ -0,0 +1,20 @@
+{
+  "id": "animeunity",
+  "name": "AnimeUnity",
+  "active": true,
+  "language": ["ita", "sub-ita"],
+  "thumbnail": "animeunity.png",
+  "banner": "animeunity.png",
+  "categories": ["anime"],
+  "settings": [
+    {
+      "id": "order",
+      "type": "list",
+      "label": "Ordine di Visualizzazione",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [ "Standard", "Lista A-Z", "Lista Z-A", "Popolarità", "Valutazione" ]
+    }
+  ]
+}

channels/animeunity.py

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per AnimeUnity
+# ------------------------------------------------------------
+
+import cloudscraper, json, copy, inspect
+from core import jsontools, support, httptools
+from platformcode import autorenumber
+
+# support.dbg()
+host = support.config.get_channel_url()
+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])}
+
+
+@support.menu
+def mainlist(item):
+    top =  [('Ultimi Episodi', ['', 'news'])]
+
+    menu = [('Anime {bullet bold}',['', 'menu', {}, 'tvshow']),
+            ('Film {submenu}',['', 'menu', {'type': 'Movie'}]),
+            ('TV {submenu}',['', 'menu', {'type': 'TV'}, 'tvshow']),
+            ('OVA {submenu} {tv}',['', 'menu', {'type': 'OVA'}, 'tvshow']),
+            ('ONA {submenu} {tv}',['', 'menu', {'type': 'ONA'}, 'tvshow']),
+            ('Special {submenu} {tv}',['', 'menu', {'type': 'Special'}, 'tvshow'])]
+    search =''
+    return locals()
+
+def menu(item):
+    item.action = 'peliculas'
+    ITA = copy.copy(item.args)
+    ITA['title'] = '(ita)'
+    InCorso = copy.copy(item.args)
+    InCorso['status'] = 'In Corso'
+    Terminato = copy.copy(item.args)
+    Terminato['status'] = 'Terminato'
+    itemlist = [item.clone(title=support.typo('Tutti','bold')),
+                item.clone(title=support.typo('ITA','bold'), args=ITA),
+                item.clone(title=support.typo('Genere','bold'), action='genres'),
+                item.clone(title=support.typo('Anno','bold'), action='years')]
+    if item.contentType == 'tvshow':
+        itemlist += [item.clone(title=support.typo('In Corso','bold'), args=InCorso),
+                     item.clone(title=support.typo('Terminato','bold'), args=Terminato)]
+    itemlist +=[item.clone(title=support.typo('Cerca...','bold'), action='search', thumbnail=support.thumb('search'))]
+    return itemlist
+
+
+def genres(item):
+    support.info()
+    # support.dbg()
+    itemlist = []
+
+    genres = json.loads(support.match(response.text, patron='genres="([^"]+)').match.replace('"','"'))
+
+    for genre in genres:
+        item.args['genres'] = [genre]
+        itemlist.append(item.clone(title=support.typo(genre['name'],'bold'), action='peliculas'))
+    return support.thumb(itemlist)
+
+def years(item):
+    support.info()
+    itemlist = []
+
+    from datetime import datetime
+    current_year = datetime.today().year
+    oldest_year = int(support.match(response.text, patron='anime_oldest_date="([^"]+)').match)
+
+    for year in list(reversed(range(oldest_year, current_year + 1))):
+        item.args['year']=year
+        itemlist.append(item.clone(title=support.typo(year,'bold'), action='peliculas'))
+    return itemlist
+
+
+def search(item, text):
+    support.info('search', item)
+    if not item.args:
+        item.args = {'title':text}
+    else:
+        item.args['title'] = text
+    item.search = text
+
+    try:
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info('search log:', line)
+        return []
+
+
+def newest(categoria):
+    support.info(categoria)
+    itemlist = []
+    item = support.Item()
+    item.url = host
+
+    try:
+        itemlist = news(item)
+
+        if itemlist[-1].action == 'news':
+            itemlist.pop()
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info(line)
+        return []
+
+    return itemlist
+
+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('"','"'))
+    js = fullJs['data']
+
+    for it in js:
+        if it.get('anime', {}).get('title'):
+            itemlist.append(
+                item.clone(title= support.typo(it['anime']['title'] + ' - EP. ' + it['number'], 'bold'),
+                           fulltitle=it['anime']['title'],
+                           thumbnail=it['anime']['imageurl'],
+                           forcethumb = True,
+                           scws_id=it.get('scws_id', ''),
+                        #    video_url=it.get('link', ''),
+                           plot=it['anime']['plot'],
+                           action='findvideos')
+            )
+    if 'next_page_url' in fullJs:
+        itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'),thumbnail=support.thumb(), url=fullJs['next_page_url']))
+    return itemlist
+
+
+def peliculas(item):
+    support.info()
+    itemlist = []
+
+    page = item.page if item.page else 0
+    item.args['offset'] = page * 30
+
+    order = support.config.get_setting('order', item.channel)
+    if order:
+        order_list = [ "Standard", "Lista A-Z", "Lista Z-A", "Popolarità", "Valutazione" ]
+        item.args['order'] = order_list[order]
+
+    payload = json.dumps(item.args)
+    records = httptools.downloadpage(host + '/archivio/get-animes', headers=headers, post=payload).json['records']
+    # support.dbg()
+
+    for it in records:
+        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 = '{}/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.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.get('scws_id', '')
+
+        itemlist.append(itm)
+
+    autorenumber.start(itemlist)
+    if len(itemlist) >= 30:
+        itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), thumbnail=support.thumb(), page=page + 1))
+
+    return itemlist
+
+def episodios(item):
+    support.info()
+    itemlist = []
+    title = 'Parte' if item.type.lower() == 'movie' else 'Episodio'
+    for it in item.episodes:
+        itemlist.append(
+            item.clone(title=support.typo('{}. {} {}'.format(it['number'], title, it['number']), 'bold'),
+                       episode = it['number'],
+                       fulltitle=item.title,
+                       show=item.title,
+                       contentTitle='',
+                       contentSerieName=item.contentSerieName,
+                       thumbnail=item.thumbnail,
+                       plot=item.plot,
+                       action='findvideos',
+                       contentType='episode',
+                       url = '{}/{}'.format(item.url, it['id'])
+                      )
+                    #    video_url=it.get('link', ''))
+            )
+
+    if inspect.stack(0)[1][3] not in ['find_episodes']:
+        autorenumber.start(itemlist, item)
+    support.videolibrary(itemlist, item)
+    support.download(itemlist, item)
+    return itemlist
+
+
+def findvideos(item):
+    # if item.scws_id:
+    #     from time import time
+    #     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

@@ -0,0 +1,21 @@
+{
+    "id": "animeuniverse",
+    "name": "AnimeHDitalia",
+    "active": false,
+    "language": ["ita", "sub-ita"],
+    "thumbnail": "animeuniverse.png",
+    "banner": "animeuniverse.png",
+    "categories": ["anime", "sub-ita"],
+    "default_off": ["include_in_newest"],
+    "settings": [
+        {
+            "id": "perpage",
+            "type": "list",
+            "label": "Elementi per pagina",
+            "default": 3,
+            "enabled": true,
+            "visible": true,
+            "lvalues": ["20","30","40","50","60","70","80","90","100"]
+        }
+    ]
+}

channels/animeuniverse.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per animeuniverse
+# ----------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+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>[^"]+)"[^>]+>\s*<img [^>]+Streaming'
+
+
+@support.menu
+def mainlist(item):
+    anime=['/anime/',
+           ('Tipo',['', 'menu', 'Anime']),
+           ('Anno',['', 'menu', 'Anno']),
+           ('Genere', ['', 'menu','Genere']),
+           ('Ultimi Episodi',['/2/', 'peliculas', 'last']),
+           ('Hentai', ['/hentai/', 'peliculas'])]
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    action = 'peliculas'
+    patronBlock = item.args + r'</a>\s*<ul class="sub-menu">(?P<block>.*?)</ul>'
+    patronMenu = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)<'
+    return locals()
+
+
+def search(item, texto):
+    support.info(texto)
+    item.search = 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 []
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.url = host
+            item.args = "last"
+            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 []
+
+
+@support.scrape
+def peliculas(item):
+    query = ''
+    if '/mos/' in item.url:
+        item.contentType = 'movie'
+        action='findvideos'
+    elif item.args == 'last':
+        query='cat%5D=1&currentquery%5Bcategory__not_in%5D%5B'
+        searchtext=''
+        item.contentType = 'episode'
+        action='findvideos'
+    else:
+        item.contentType = 'tvshow'
+        action='episodios'
+    if item.search:
+        query = 's'
+        searchtext = item.search
+    if not query:
+        query='category_name'
+        searchtext = item.url.split('/')[-2] if item.url != host else ''
+    if not item.pag: item.pag = 1
+
+    anime=True
+    # blacklist=['Altri Hentai']
+    data = support.match(host + '/wp-content/themes/animeuniverse/functions/ajax.php', post='sorter=recent&location=&loop=main+loop&action=sort&numarticles='+perpage+'&paginated='+str(item.pag)+'&currentquery%5B'+query+'%5D='+searchtext+'&thumbnail=1').data.replace('\\','')
+    patron=r'<a href="(?P<url>[^"]+)"><img width="[^"]+" height="[^"]+" src="(?P<thumb>[^"]+)" class="[^"]+" alt="" title="(?P<title>.*?)\s*(?P<lang>Sub ITA|ITA)?(?:"| \[)'
+
+    def itemlistHook(itemlist):
+        if len(itemlist) == int(perpage):
+            item.pag += 1
+            itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), action='peliculas'))
+        return itemlist
+    return locals()
+
+
+
+
+@support.scrape
+def episodios(item):
+    anime = True
+    pagination = int(perpage)
+    patron = epPatron
+    # debug = True
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    if item.contentType == 'movie':
+        matches = support.match(item, patron=epPatron).matches
+        for title, url in matches:
+            get_video_list(url, title, itemlist)
+    else:
+        get_video_list(item.url, support.config.get_localized_string(30137), itemlist)
+    return support.server(item, itemlist=itemlist)
+
+
+def get_video_list(url, title, itemlist):
+    from requests import get
+    if not url.startswith('http'): url = host + url
+
+    url = support.match(get(url).url, string=True, patron=r'file=([^$]+)').match
+    if 'http' not in url: url = 'http://' + url
+    itemlist.append(support.Item(title=title, url=url, server='directo', action='play'))
+
+    return itemlist

channels/animeworld.json

@@ -0,0 +1,29 @@
+{
+    "id": "animeworld",
+    "name": "AnimeWorld",
+    "active": true,
+    "language": ["ita", "sub-ita"],
+    "thumbnail": "animeworld.png",
+    "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",
+            "label": "Ordine di Visualizzazione",
+            "default": 0,
+            "enabled": true,
+            "visible": true,
+            "lvalues": [ "Standard", "Ultime Aggiunte", "Lista A-Z", "Lista A-Z", "Più Vecchi", "Più Recenti", "Più Visti" ]
+        }
+    ]
+}

channels/animeworld.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per animeworld
+# thanks to fatshotty
+# ----------------------------------------------------------
+
+from core import httptools, support, config, jsontools
+
+host = support.config.get_channel_url()
+__channel__ = 'animeworld'
+cookie = support.config.get_setting('cookie', __channel__)
+headers = [['Cookie', cookie]]
+
+
+def get_cookie(data):
+    global cookie, headers
+    cookie = support.match(data, patron=r'document.cookie="([^\s]+)').match
+    support.config.set_setting('cookie', cookie, __channel__)
+    headers = [['Cookie', cookie]]
+
+
+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 'SecurityAW' in data:
+        get_cookie(data)
+        data = get_data(item)
+    return data
+
+
+def order():
+    # Seleziona l'ordinamento dei risultati
+    return str(support.config.get_setting("order", __channel__))
+
+
+@support.menu
+def mainlist(item):
+    anime=['/filter?sort=',
+           ('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' ]),
+           ('Generi',['/?d=1','genres',])]
+    return locals()
+
+
+@support.scrape
+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>'
+
+    def itemHook(item):
+        item.url = host + '/filter?' + item.name + '=' + item.value + '&sort='
+        return item
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    action = 'submenu'
+    data = get_data(item)
+    patronMenu=r'<button[^>]+>\s*(?P<title>[A-Za-z0-9]+)\s*<span.[^>]+>(?P<other>.*?)</ul>'
+    def itemlistHook(itemlist):
+        itemlist.insert(0, item.clone(title=support.typo('Tutti','bold'), action='peliculas'))
+        itemlist.append(item.clone(title=support.typo('Cerca...','bold'), action='search', search=True, thumbnail=support.thumb('search.png')))
+        return itemlist
+    return locals()
+
+
+@support.scrape
+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 = '{}/filter?{}={}&{}{}'.format(host, item.name, item.value, item.args, ('&sort=' if item.name != 'sort' else ''))
+        return item
+    return locals()
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    lang = config.get_setting('lang', channel=item.channel)
+    try:
+        if categoria == "anime":
+            item.url = host
+            item.args = "updated"
+            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, text):
+    support.info(text)
+    if item.search:
+        item.url = '{}/filter?{}&keyword={}&sort='.format(host, item.args, text)
+    else:
+        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)
+    # 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 peliculas(item):
+    data = get_data(item)
+    anime = 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>)?(?:[^>]+>){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>)?'
+        action='episodios'
+
+    # Controlla la lingua se assente
+    patronNext=r'<a href="([^"]+)" class="[^"]+" id="go-next'
+    typeContentDict={'movie':['movie', 'special']}
+    typeActionDict={'findvideos':['movie', 'special']}
+    def itemHook(item):
+        if not item.contentLanguage:
+            if 'dub=1' in item.url or item.l == 'dub':
+                item.contentLanguage = 'ITA'
+                item.title += support.typo(item.contentLanguage,'_ [] color kod')
+            else:
+                item.contentLanguage = 'Sub-ITA'
+                item.title += support.typo(item.contentLanguage,'_ [] color kod')
+        return item
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    data = get_data(item)
+    anime = True
+    pagination = 50
+    patronBlock= r'<div class="server\s*active\s*"(?P<block>.*?)(?:<div class="server|<link)'
+    patron = r'<li[^>]*>\s*<a.*?href="(?P<url>[^"]+)"[^>]*>(?P<episode>[^-<]+)(?:-(?P<episode2>[^<]+))?'
+    def itemHook(item):
+        item.number = support.re.sub(r'\[[^\]]+\]', '', item.title)
+        item.title += support.typo(item.fulltitle,'-- bold')
+        return item
+    action='findvideos'
+    return locals()
+
+
+def findvideos(item):
+    import time
+    support.info(item)
+    itemlist = []
+    urls = []
+    # resp = support.match(get_data(item), headers=headers, patron=r'data-name="(\d+)">([^<]+)<')
+    resp = support.match(get_data(item), headers=headers, patron=r'data-name="(\d+)">([^<]+)<')
+    data = resp.data
+
+    for ID, name in resp.matches:
+        if not item.number: item.number = support.match(item.title, patron=r'(\d+) -').match
+        match = support.match(data, patronBlock=r'data-name="' + ID + r'"[^>]+>(.*?)(?:<div class="(?:server|download)|link)', patron=r'data-id="([^"]+)" data-episode-num="' + (item.number if item.number else '1') + '"' + r'.*?href="([^"]+)"').match
+        if match:
+            epID, epurl = match
+            # if 'vvvvid' in name.lower():
+            #     urls.append(support.match(host + '/api/episode/ugly/serverPlayerAnimeWorld?id=' + epID, headers=headers, patron=r'<a.*?href="([^"]+)"', debug=True).match)
+            if 'animeworld' in name.lower():
+                url = support.match(data, patron=r'href="([^"]+)"\s*id="alternativeDownloadLink"', headers=headers).match
+                title = support.match(url, patron=r'http[s]?://(?:www.)?([^.]+)', string=True).match
+                itemlist.append(item.clone(action="play", title=title, url=url, server='directo'))
+            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

@@ -0,0 +1,37 @@
+{
+    "id": "aniplay",
+    "name": "AniPlay",
+    "active": true,
+    "language": ["ita", "sub-ita"],
+    "thumbnail": "aniplay.png",
+    "banner": "aniplay.png",
+    "categories": ["anime", "vos"],
+    "settings": [
+        {
+            "id": "sort",
+            "type": "list",
+            "label": "Ordine di Visualizzazione",
+            "default": 0,
+            "enabled": true,
+            "visible": true,
+            "lvalues": [ "Popolarità", "Titolo", "Numero Episodi", "Data di inizio", "Data di fine", "Data di aggiunta"]
+        },
+        {
+            "id": "order",
+            "type": "bool",
+            "label": "Visualizza in ordine Discendente?",
+            "default": false,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "perpage",
+            "type": "list",
+            "label": "Numero di elementi per pagina",
+            "default": 1,
+            "enabled": true,
+            "visible": true,
+            "lvalues": ["10", "20", "30", "40", "50", "60", "80", "90"]
+        }
+  ]
+}

channels/aniplay.py

@@ -0,0 +1,331 @@
+from platformcode import config, logger, autorenumber
+from core import httptools, scrapertools, support, tmdb, jsontools
+from inspect import stack
+
+import sys
+if sys.version_info[0] >= 3:
+    from concurrent import futures
+else:
+    from concurrent_py2 import futures
+
+host = config.get_channel_url()
+sort = ['views', 'title', 'episodeNumber', 'startDate', 'endDate', 'createdDate'][config.get_setting('sort', 'aniplay')]
+order = 'asc' if config.get_setting('order', 'aniplay') else 'desc'
+perpage = [10, 20, 30 ,40, 50, 60, 70, 80, 90][config.get_setting('perpage', 'aniplay')]
+
+
+@support.menu
+def mainlist(item):
+    anime=['/api/anime/advanced-search',
+           ('A-Z', ['/api/anime/advanced-search', 'submenu_az', '']),
+           ('Anno', ['', 'submenu_year', '']),
+           ('Top', ['', 'submenu_top', '']),
+           ('Ultimi aggiunti', ['', 'latest_added', ''])]
+    return locals()
+
+
+def submenu_az(item):
+    itemlist = []
+    for letter in ['0-9'] + list('ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
+        itemlist.append(item.clone(title = support.typo(letter, 'bold'),
+                                url= host + '/api/anime/find-by-char',
+                                action= 'peliculas',
+                                variable= '&character=' + letter,
+                                thumbnail=support.thumb('az')))
+    return itemlist
+
+
+def submenu_year(item):
+    itemlist = []
+    from datetime import date
+    current = date.today().year
+    first = int(httptools.downloadpage('{}/api/anime/advanced-search?page=0&size=1&sort=startDate,asc&sort=id'.format(host)).json[0]['startDate'].split('-')[0]) -1
+    for year in range(current, first, -1):
+        itemlist.append(item.clone(title = support.typo(year, 'bold'),
+                                action= 'submenu_season',
+                                variable= year,
+                                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'}
+    for label in links:
+        link = links[label]
+        itemlist.append(item.clone(title = support.typo(label, 'bold'),
+                                action= 'submenu_top_of',
+                                variable= link))
+    return itemlist
+
+
+def submenu_season(item):
+    itemlist = []
+    seasons = {'winter':'Inverno', 'spring':'Primavera', 'summer':'Estate', 'fall':'Autunno'}
+    url= '{}/api/seasonal-view?page=0&size=36&years={}'.format(host, item.variable)
+    js = httptools.downloadpage(url).json[0]['seasonalAnime']
+    for season in js:
+        s = season['season'].split('.')[-1]
+        title = seasons[s]
+        itemlist.append(item.clone(title=title,
+                                   url = '{}/api/seasonal-view/{}-{}'.format(host, s, item.variable),
+                                   thumbnail = support.thumb(s),
+                                   action = 'peliculas',
+                                   variable=''))
+    return itemlist
+
+
+def submenu_top_of(item):
+    itemlist = []
+    url= '{}/api/home/{}'.format(host, item.variable)
+    js = httptools.downloadpage(url).json
+    for anime in js:
+        fulltitle = anime['animeTitle']
+        title = fulltitle.split('(')[0].strip()
+        scrapedlang = scrapertools.find_single_match(fulltitle, r'\(([^\)]+)')
+        lang = scrapedlang.upper() if scrapedlang else 'Sub-ITA'
+        long_title = support.typo(title, 'bold') + support.typo(lang, '_ [] color kod')
+
+        itemlist.append(item.clone(title=long_title,
+                                   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'
+    item.variable = '&query=' + 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 []
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            return latest_added(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 latest_added(item):
+    itemlist = []
+    page = item.page if item.page else 0
+    url= '{}/api/home/latest-episodes?page={}'.format(host, page)
+    js = httptools.downloadpage(url).json
+
+    for episode in js:
+        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')
+        image = get_thumbnail(episode, 'episodeImages')
+
+        itemlist.append(item.clone(title=long_title,
+                                   fulltitle=title,
+                                   url='{}/play/{}'.format(host, episode['id']),
+                                   contentType = 'episode',
+                                   contentTitle = title,
+                                   contentSerieName = animeTitle,
+                                   contentLanguage = lang,
+                                   quality = quality,
+                                   contentEpisodeNumber = int(float(episode['episodeNumber'])),
+                                   video_url = '{}/api/episode/{}'.format(host, episode['id']),
+                                   thumbnail = image,
+                                   fanart = image,
+                                   action = 'findvideos'))
+
+    if stack()[1][3] not in ['newest']:
+        support.nextPage(itemlist, item.clone(page = page + 1))
+
+    return itemlist
+
+
+def peliculas(item):
+    logger.debug()
+
+    itemlist = []
+    page = item.page if item.page else 0
+    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')
+
+        itemlist.append(item.clone(title = long_title,
+                                   fulltitle = title,
+                                   show = title,
+                                   contentLanguage = lang,
+                                   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',
+                                   plot = it['storyline'],
+                                   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')))
+
+    autorenumber.start(itemlist)
+    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+
+    if len(itemlist) == perpage:
+        support.nextPage(itemlist, item.clone(page = page + 1))
+    return itemlist
+
+
+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.video_url, CF=False ).json
+
+    if type(json) == list:
+        item.show_renumber = False
+        itemlist = list_episodes(item, json)
+
+    elif json.get('seasons'):
+        seasons = json['seasons']
+        seasons.sort(key=lambda s: s['episodeStart'])
+
+        for it in seasons:
+            title = it['name']
+
+            itemlist.append(item.clone(title = title,
+                                       video_url = '{}/api/anime/{}/season/{}'.format(host, it['animeId'], it['id']),
+                                       contentType = 'season',
+                                       action = 'list_episodes',
+                                       plot = json['storyline'],
+                                       year = it['yearStart'],
+                                       show_renumber = True))
+
+        # If the call come from the videolibrary or autorenumber, shows the episodes
+        if stack()[1][3] in ['add_tvshow', 'get_episodes', 'update', 'find_episodes']:
+            itlist = []
+            with futures.ThreadPoolExecutor() as executor:
+                eplist = []
+                for ep in itemlist:
+                    ep.show_renumber = False
+                    eplist.append(executor.submit(list_episodes, ep))
+                for res in futures.as_completed(eplist):
+                    if res.result():
+                        itlist.extend(res.result())
+            itemlist = itlist
+    elif json.get('episodes'):
+        itemlist = list_episodes(item, json)
+
+    # add renumber option
+    if stack()[1][3] not in ['find_episodes'] and itemlist and itemlist[0].contentType == 'episode':
+        autorenumber.start(itemlist, item)
+
+    # add add to videolibrary menu
+    if stack()[1][3] not in ['add_tvshow', 'get_episodes', 'update', 'find_episodes']:
+        support.videolibrary(itemlist, item)
+
+    return itemlist
+
+
+def list_episodes(item, json=None):
+    itemlist = []
+
+    if not 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]))
+
+    for it in episodes:
+        quality = 'Full HD' if it['fullHd'] else 'HD'
+
+        if item.contentSeason:
+            episode = '{}x{:02d}'.format(item.contentSeason, int(it['episodeNumber'].split('.')[0]))
+        else:
+            episode = '{:02d}'.format(int(it['episodeNumber'].split('.')[0]))
+
+        title = support.typo('{}. {}'.format(episode, it['title']), 'bold')
+        image = get_thumbnail(it, 'episodeImages')
+
+        itemlist.append(item.clone(title = title,
+                                   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 '',
+                                   action = 'findvideos',
+                                   quality = quality,
+                                   thumbnail = image,
+                                   fanart= image))
+
+    # Renumber episodes only if shown in the menu
+    if item.show_renumber:
+        autorenumber.start(itemlist, item)
+
+    return itemlist
+
+
+def findvideos(item):
+    logger.debug()
+
+    res = httptools.downloadpage(item.video_url, CF=False ).json
+
+    if res.get('episodes', []):
+        res = httptools.downloadpage('{}/api/episode/{}'.format(host, res['episodes'][0]['id'])).json
+
+    item.url = res['videoUrl']
+    item.server = 'directo'
+
+    if '.m3u' in item.url:
+        item.manifest = 'hls'
+
+    return support.server(item, itemlist=[item])
+
+
+def get_thumbnail(data, prop = 'verticalImages', key = 'full'):
+    """
+    " Returns the vertical image as per given key and prop
+    " possibile key values are:
+    " - small
+    " - full
+    " - blurred
+    " - medium
+    " possibile prop values are:
+    " - verticalImages
+    " - animeHorizontalImages
+    " - animeVerticalImages
+    " - horizontalImages
+    " - episodeImages
+    """
+    value = None
+    verticalImages = data.get(prop, [])
+    if verticalImages:
+        first = verticalImages[0]
+        if first:
+            value = first.get('image' + key.capitalize(), '')
+    return value
+
+
+def get_lang(value):
+    title = value.split('(')[0] if value else ''
+    scrapedlang = scrapertools.find_single_match(value, r'\(([^\)]+)')
+    lang = scrapedlang.upper() if scrapedlang else 'Sub-ITA'
+    return title, lang

channels/casacinema.json

@@ -0,0 +1,11 @@
+{
+    "id": "casacinema",
+    "name": "Casacinema",
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "casacinema.png",
+    "banner": "casacinema.png",
+    "categories": ["tvshow", "movie","vos"],
+    "settings": [
+    ]
+}

channels/casacinema.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'casacinema'
+# ------------------------------------------------------------
+
+
+from core import support
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    film = ['/category/film',
+        ('Generi', ['', 'genres', 'genres']),
+        ]
+
+    tvshow = ['/category/serie-tv',
+        ('Novità', ['/aggiornamenti-serie-tv', 'peliculas', '']),
+        ]
+
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    action = 'peliculas'
+    blacklist = ['PRIME VISIONI', 'ULTIME SERIE TV', 'ULTIMI FILM']
+    patronMenu = r'<li><a href="(?P<url>[^"]+)">(?P<title>[^<>]+)</a></li>'
+    patronBlock = r'<div class="container home-cats">(?P<block>.*?)<div class="clear">'
+    return locals()
+
+
+def check(item):
+    item.data = support.match(item).data
+    if 'episodi e stagioni' in item.data.lower():
+        support.info('select = ### è una serie ###')
+        item.contentType = 'tvshow'
+        return episodios(item)
+    else:
+        support.info('select = ### è un film ###')
+        item.contentType = 'movie'
+        return findvideos(item)
+
+
+def search(item, text):
+    support.info(text)
+    text = text.replace(' ', '+')
+    item.url = host + '/?a=b&s=' + text
+    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)
+        return []
+
+    return itemlist
+
+
+@support.scrape
+def peliculas(item):
+    if item.contentType == 'movie':
+        action = 'findvideos'
+    elif item.contentType == 'tvshow':
+        action = 'episodios'
+        pagination = ''
+    else:
+        action = 'check'
+
+    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<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}\))?<'
+
+    patronNext = r'<a href="([^"]+)"\s*>Pagina'
+
+
+    def itemHook(item):
+        if item.quality1:
+            item.quality = item.quality1
+            item.title += support.typo(item.quality, '_ [] color kod')
+        if item.lang2:
+            item.contentLanguage = item.lang2
+            item.title += support.typo(item.lang2, '_ [] color kod')
+        if item.args == 'novita':
+            item.title = item.title
+
+        return item
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    if item.data:
+        data = item.data
+    action = 'findvideos'
+    item.contentType = 'tvshow'
+    blacklist = ['']
+    patron = r'"season-no">(?P<season>\d+)x(?P<episode>\d+)(?:[^>]+>){5}\s*(?P<title>[^<]+)(?P<data>.*?)</table>'
+    patronBlock = r'<span>(?:.+?Stagione*.+?(?P<lang>[Ii][Tt][Aa]|[Ss][Uu][Bb][\-]?[iI][tT][aA]))?.*?</span>.*?class="content(?P<block>.*?)(?:"accordion-item|<script>)'
+    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 support.match(item.url, headers=headers).data
+        links = support.match(matchData, patron=r'data-id="([^"]+)"').matches
+
+    return support.server(item, links)

channels/cb01anime.json

@@ -0,0 +1,10 @@
+{
+    "id": "cb01anime",
+    "name": "Cb01anime",
+    "language": ["ita", "vos", "sub-ita"],
+    "active": false,
+    "thumbnail": "cb01anime.png",
+    "banner": "cb01anime.png",
+    "categories": ["anime"],
+    "settings": []
+}

channels/cb01anime.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# XBMC Plugin
+# Canale  per cineblog01 - anime
+# ------------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url() + '/cb01-anime-cartoon'
+
+Blacklist = ['AVVISO IMPORTANTE – CB01.ROCKS', 'Lista Alfabetica Completa Anime/Cartoon', 'CB01.UNO ▶ TROVA L’INDIRIZZO UFFICIALE','Lista Richieste Up & Re-Up']
+
+
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    anime = [('Genere',['','menu', '2']),
+             ('Per Lettera',['','menu', '1']),
+             ('Per Anno',['','menu', '3']),
+             ('Ultimi Anime Aggiornati',['','peliculas', 'newest'])]
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    blacklist = ['Anime per Genere', 'Anime per Anno', 'Anime per Lettera']
+    patronBlock = r'<select name="select%s"(?P<block>.*?)</select>' % item.args
+    patronMenu = r'<option value="(?P<url>[^"]+)">(?P<title>[^<]+)</option>'
+    action = 'peliculas'
+    def itemHook(item):
+        item.url = item.url.replace('cb01-anime/','cb01-anime-cartoon/')
+        return item
+    return locals()
+
+
+def search(item, texto):
+    support.info(texto)
+    item.url = host + "/search/" + texto
+    try:
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info('search log:', line)
+        return []
+
+
+def newest(categoria):
+    support.info(categoria)
+    itemlist = []
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.url = host
+            item.args = 'newest'
+            itemlist = 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 []
+
+    return itemlist
+
+@support.scrape
+def peliculas(item):
+    # debug=True
+    blacklist = Blacklist
+    item.contentType = 'tvshow'
+    if item.args == 'newest':
+        patron = r'<div id="blockvids">\s*<ul>\s*<li>\s*<a href="(?P<url>[^"]+)"[^>]+><img[^>]+src="(?P<thumb>[^"]+)"[^>]*>(?:[^>]+>){4}(?P<title>[^\[]+)\[(?P<lang>[^\]]+)\]'
+    else:
+        patron = r'<div class="span4">\s*<a href="(?P<url>[^"]+)"><img src="(?P<thumb>[^"]+)"[^>]+><\/a>(?:[^>]+>){7}\s*<h1>(?P<title>[^<\[]+)(?:\[(?P<lang>[^\]]+)\])?</h1></a>.*?-->(?:.*?<br(?: /)?>)?\s*(?P<plot>[^<]+)'
+        patronNext = r'<link rel="next" href="([^"]+)"'
+    action = 'check'
+    return locals()
+
+def check(item):
+    # support.dbg()
+    item.url = support.match(item, patron=r'(?:<p>|/>)(.*?)(?:<br|</td>|</p>)', patronBlock=r'Streaming:(.*?)</tr>').matches
+    if 'Episodio' in str(item.url):
+        item.contentType = 'tvshow'
+        item.action ='episodios'
+        return episodios(item)
+    else:
+        item.contentType = 'movie'
+        item.action = 'findvideos'
+        return findvideos(item)
+
+@support.scrape
+def episodios(item):
+    support.info('EPISODIOS ', item.data)
+    data = ''
+    matches = item.data
+    season = 1
+    s = 1
+    e = 0
+    sp = 0
+
+    for match in item.url:
+        if 'stagione' in match.lower():
+            find_season = support.match(match, patron=r'Stagione\s*(\d+)').match
+            season = int(find_season) if find_season else season + 1 if 'prima' not in match.lower() else season
+        else:
+            try: title = support.match(match, patron=r'<a[^>]+>([^<]+)</a>').match
+            except: title = ''
+            if title:
+                if 'episodio' in title.lower():
+                    ep = support.match(match, patron=r'Episodio ((?:\d+.\d|\d+|\D+))').match
+                    check = ep.isdigit()
+                    if check or '.' in ep:
+                        if '.' in ep:
+                            sp += 1
+                            title = '0' + 'x' + str(sp).zfill(2) + ' - ' + title
+                        else:
+                            ep = int(ep)
+                            if season > s and ep > 1:
+                                s += 1
+                                e = ep - 1
+                            title = str(season) + 'x' + str(ep-e).zfill(2) + ' - ' + title
+                        data += title + '|' + match + '\|'
+                    else:
+                        title += ' #movie'
+                        data += title + '|' + match + '\|'
+    def itemHook(item):
+        if '#movie' in item.title:
+            item.contentType='movie'
+            item.title = item.title.replace(' #movie','')
+        return item
+
+    patron = r'(?P<title>[^\|]+)\|(?P<url>[^\|]+)\|'
+    action = 'findvideos'
+    return locals()
+
+def findvideos(item):
+    return support.server(item, item.url)
+

channels/cineblog01.json

@@ -0,0 +1,10 @@
+{
+	"id": "cineblog01",
+	"name": "CB01",
+	"language": ["ita", "sub-ita"],
+	"active": true,
+	"thumbnail": "cb01.png",
+	"banner": "cb01.png",
+	"categories": ["tvshow", "movie", "vos", "documentary"],
+	"settings": []
+}

channels/cineblog01.py

@@ -0,0 +1,242 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per cineblog01
+# ------------------------------------------------------------
+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
+
+
+host = config.get_channel_url(findhost)
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    film = [
+        ('HD', ['', 'menu', 'Film HD Streaming']),
+        ('Genere', ['', 'menu', 'Film per Genere']),
+        ('Anni', ['', 'menu', 'Film per Anno']),
+        ('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 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'])
+            ]
+
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    # debug = True
+    patronBlock = item.args + r'<span.*?><\/span>.*?<ul.*?>(?P<block>.*?)<\/ul>'
+    patronMenu = r'href="?(?P<url>[^">]+)"?[^>]+>(?P<title>[^<»]+)'
+    action = 'peliculas'
+
+    return locals()
+
+
+def newest(categoria):
+    support.info(categoria)
+
+    item = support.Item()
+    try:
+        if categoria == "series":
+            item.contentType = 'tvshow'
+            item.url = host + '/serietv/'  # aggiornamento-quotidiano-serie-tv/'
+        else:
+            item.contentType = 'movie'
+            item.url = host + '/ultimi-100-film-aggiunti/'
+            item.args = "newest"
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("{0}".format(line))
+        return []
+
+
+def search(item, text):
+    logger.info("search", text)
+    if item.contentType == 'tvshow': item.url = host + '/serietv'
+    else: item.url = host
+    try:
+        item.url = item.url + "/search/" + text.replace(' ', '+')
+        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):
+    #debug = True
+    # esclusione degli articoli 'di servizio'
+    # curYear = datetime.date.today().year
+    # blacklist = ['BENVENUTI', 'Richieste Serie TV', 'CB01.UNO &#x25b6; TROVA L&#8217;INDIRIZZO UFFICIALE ',
+    #              'Aggiornamento Quotidiano Serie TV', 'AVVISO!!!',
+    #              'Openload: la situazione. Benvenuto Verystream', 'Openload: lo volete ancora?',
+    #              'OSCAR ' + str(curYear) + ' &#x25b6; VOTA IL TUO FILM PREFERITO! &#x1f3ac;',
+    #              'Auguri di Buon Natale e Felice Anno Nuovo! &#8211; ' + str(curYear) + '!']
+
+    if 'newest' in item.args:
+        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]+(?:[/]?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>[^<]+)<'
+            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]+(?:[/]?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:
+        patron = r'(?<!sticky )hentry.*?card-image[^>]*>\s*<a href=(?:")?(?P<url>[^" >]+)(?:")?\s*>\s*<img src=(?:")?(?P<thumb>[^" ]+)(?:")? alt="(?P<title>.*?)(?: &#8211; \d+&#215;\d+)?(?:"| &#8211; )(?:(?P<lang>Sub-ITA|ITA))?[^>]*>[^>]+>[^>]+>[^>]*>[^>]+>[^>]+>[^>]*>[^>]+>[^>]+>[^>]*>[^>]+>[^>]+>[^>]*>(?P<genre>[^\(]+)\((?P<year>\d{4})[^>]*>[^>]+>[^>]+>[^>]+>(?:<p>)?(?P<plot>[^<]+)'
+        action = 'episodios'
+        item.contentType = 'tvshow'
+
+    patronNext = '<a class="?page-link"? href="?([^>"]+)"?><i class="fa fa-angle-right">'
+
+    def itemHook(item):
+        if item.quality2:
+            item.quality = item.quality2
+            item.title += support.typo(item.quality2, '_ [] color kod')
+        return item
+
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    @support.scrape
+    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
+
+            patron = r'<tr><td>(?P<title>[^<]+)<td><span [^>].+?><a [^>]+href="(?P<url>[^"]+)[^>]+>'
+            sceneTitle = True
+            # debug = True
+
+            def itemHook(item):
+                item.serieFolder = True
+                return item
+        return locals()
+
+    # debugBlock=True
+    data = support.match(item.url, headers=headers).data
+    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)'
+    def itemlistHook(itemlist):
+        title_dict = {}
+        itlist = []
+        for i in itemlist:
+            i.url = item.url
+            i.title = re.sub(r'\.(\D)',' \\1', i.title)
+            match = support.match(i.title, patron=r'(\d+.\d+)').match.replace('x','')
+            i.order = match
+            if match not in title_dict:
+                title_dict[match] = i
+            elif match in title_dict and i.contentLanguage == title_dict[match].contentLanguage \
+                or i.contentLanguage == 'ITA' and not title_dict[match].contentLanguage \
+                or title_dict[match].contentLanguage == 'ITA' and not i.contentLanguage:
+                title_dict[match].url = i.url
+            else:
+                title_dict[match + '1'] = i
+
+        for key, value in title_dict.items():
+            itlist.append(value)
+
+        itlist = sorted(itlist, key=lambda it: (it.contentLanguage, int(it.order)))
+
+        itlist.extend(folderItemlist)
+
+        return itlist
+    return locals()
+
+
+def findvideos(item):
+    if item.serieFolder:
+        return support.server(item, data=item.url)
+    if item.contentType == "episode":
+        return findvid_serie(item)
+
+    def load_links(itemlist, re_txt, desc_txt, quality=""):
+        streaming = scrapertools.find_single_match(data, re_txt).replace('"', '')
+        logger.debug('STREAMING=', streaming)
+        matches = support.match(streaming, patron = r'<td><a.*?href=([^ ]+) [^>]+>([^<]+)<').matches
+        for scrapedurl, scrapedtitle in matches:
+            logger.debug("##### findvideos %s ## %s ## %s ##" % (desc_txt, scrapedurl, scrapedtitle))
+            itemlist.append(item.clone(action="play", title=scrapedtitle, url=scrapedurl, server=scrapedtitle, quality=quality))
+
+    logger.debug()
+
+    itemlist = []
+
+    # Carica la pagina
+    data = httptools.downloadpage(item.url).data
+    data = re.sub('\n|\t', '', data)
+
+    # Estrae i contenuti - Streaming
+    load_links(itemlist, '<strong>Streamin?g:</strong>(.*?)cbtable', "Streaming", "SD")
+
+    # Estrae i contenuti - Streaming HD
+    load_links(itemlist, '<strong>Streamin?g HD[^<]+</strong>(.*?)cbtable', "Streaming HD", "HD")
+
+    # Estrae i contenuti - Streaming 3D
+    load_links(itemlist, '<strong>Streamin?g 3D[^<]+</strong>(.*?)cbtable', "Streaming 3D")
+
+    # Extract the quality format
+    patronvideos = r'([\w.]+)</strong></div></td>'
+    return support.server(item, itemlist=itemlist, patronTag=patronvideos)
+
+    # Estrae i contenuti - Download
+    # load_links(itemlist, '<strong>Download:</strong>(.*?)<tableclass=cbtable height=30>', "aqua", "Download")
+
+    # Estrae i contenuti - Download HD
+    # load_links(itemlist, '<strong>Download HD[^<]+</strong>(.*?)<tableclass=cbtable width=100% height=20>', "azure", "Download HD")
+
+
+def findvid_serie(item):
+    logger.debug()
+    data = re.sub(r'((?:<p>|<strong>)?[^\d]*\d*(?:&#215;|×)[0-9]+[^<]+)', '', item.other)
+
+    return support.server(item, data=data)
+
+
+def play(item):
+    logger.debug()
+    return servertools.find_video_items(item, data=item.url)

channels/cinemalibero.json

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

channels/cinemalibero.py

@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'cinemaLibero'
+# ------------------------------------------------------------
+
+import re
+
+from core import httptools, support, scrapertools
+from core.item import Item
+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):
+#     permUrl = httptools.downloadpage('https://www.cinemalibero.online/', follow_redirects=False).headers
+#     try:
+#         import urlparse
+#     except:
+#         import urllib.parse as urlparse
+#     p = list(urlparse.urlparse(permUrl['location'].replace('https://www.google.com/search?q=site:', '')))
+#     if not p[0]:
+#         p[0] = 'https'
+#     return urlparse.urlunparse(p)
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+
+    film = ['/category/film/',
+            ('Novità', ['', 'peliculas', 'update']),
+            ('Generi', ['', 'genres'])]
+
+    tvshow = ['/category/serie-tv/']
+
+    anime = ['/category/anime-giapponesi/']
+
+##    Sport = [(support.typo('Sport', 'bullet bold'), ['/category/sport/', 'peliculas', 'sport', 'tvshow'])]
+    news = [('Ultimi episodi Serie/Anime', ['/aggiornamenti-serie-tv/', 'peliculas', 'update', 'tvshow'])]
+
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # debug = True
+    action = 'check'
+    patronBlock = r'<div class="container">.*?class="col-md-12[^"]*?">(?P<block>.*?)<div class=(?:"container"|"bg-dark ")>'
+    if item.args == 'newest':
+        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':
+        # 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>[^\)]+)\)">'
+    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
+        else:
+            patron = r'<a href="(?P<url>[^"]+)"\s*title="(?P<title>[^"\(]+)(?:"|\()(?:(?P<year>\d+)[^"]+)?.*?url\((?P<thumb>[^\)]+)\)(?:.*?<div class="voto">[^>]+>[^>]+>\s*(?P<rating>[^<]+))?.*?<div class="titolo">[^>]+>(?:<div class="genere">[^ ]*(?:\s\d+)?\s*(?:\()?(?P<lang>[^\)< ]+))?'
+    else:
+        patron = r'<div class="col-lg-3">[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)".+?url\((?P<thumb>[^\)]+)\)">[^>]+>[^>]+>[^>]+>(?:[^>]+>)?\s?(?P<rating>[\d\.]+)?[^>]+>(?P<title>.+?)(?:[ ]\((?P<year>\d{4})\))?<[^>]+>[^>]+>(.?[\d\-x]+\s\(?(?P<lang>[sSuUbBiItTaA\-]+)?\)?\s?(?P<quality>[\w]+)?[|]?\s?(?:[fFiInNeE]+)?\s?\(?(?P<lang2>[sSuUbBiItTaA\-]+)?\)?)?'
+
+    def itemHook(item):
+        if 'sub' in item.contentLanguage.lower() and not 'ita' in item.contentLanguage.lower():
+            item.contentLanguage= 'Sub-ITA'
+            item.title = re.sub('[Ss]ub(?:-)?', item.contentLanguage, item.title)
+        if item.lang2:
+            if len(item.lang2)<3:
+                item.lang2 = 'ITA'
+            item.contentLanguage = item.lang2
+            item.title += support.typo(item.lang2, '_ [] color kod')
+        if item.args == 'update':
+            item.title = item.title.replace('-', ' ')
+        # if item.args == 'search':
+        #     item.contentType = 'tvshow' if 'serie-' in item.url else 'movie'
+
+        return item
+
+    patronNext = r'<a class="next page-numbers".*?href="([^"]+)">'
+    return locals()
+
+@support.scrape
+def episodios(item):
+    data = item.data
+    # debug=True
+
+    if item.args == 'anime':
+        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 == '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(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]+)"'
+
+    return locals()
+
+
+def search(item, texto):
+    logger.debug(item.url,texto)
+    texto = texto.replace(' ', '+')
+    item.url = host + "/?s=" + texto
+    # item.contentType = 'tv'
+    item.args = 'search'
+    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 []
+
+
+def newest(categoria):
+    logger.debug('newest ->', categoria)
+    itemlist = []
+    item = Item()
+    item.args = 'newest'
+    try:
+        if categoria == 'series' or categoria == 'anime':
+            item.args = 'update'
+            item.url = host+'/aggiornamenti-serie-tv/'
+            item.contentType = 'tvshow'
+        item.action = 'peliculas'
+        itemlist = peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error('newest log: ', (line))
+        return []
+
+    return itemlist
+
+
+def check(item):
+    data = support.match(item.url, headers=headers).data
+
+    if data:
+        ck = str(support.match(data, patronBlock=r'Genere:(.*?)</span>', patron=r'tag">([^<]+)').matches).lower()
+
+        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'
+            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.data = data
+                return findvideos(item)
+        else:
+            item.contentType = 'movie'
+            item.data = data
+            # item.action = 'findvideos'
+            return findvideos(item)
+
+        return itemlist
+
+
+def findvideos(item):
+    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

@@ -0,0 +1,11 @@
+{
+	"id": "cinetecadibologna",
+	"name": "Cineteca di Bologna",
+	"language": ["ita"],
+	"active": true,
+	"thumbnail": "cinetecadibologna.png",
+	"banner": "cinetecadibologna.png",
+	"categories": ["documentary"],
+	"not_active":["include_in_newest_peliculas", "include_in_newest_series", "include_in_newest_anime", "include_in_global_search"],
+	"settings": []
+}

channels/cinetecadibologna.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per cinetecadibologna
+# ------------------------------------------------------------
+from core.item import Item
+
+from core import support
+
+host = support.config.get_channel_url()
+
+
+headers = [['Referer', host]]
+@support.menu
+def mainlist(item):
+    film = ['/video/alfabetico_completo',
+            ('Anni',['/video/epoche', 'menu']),
+            ('Registi',['/video/registi', 'menu']),
+            ('Attori',['/video/attori', 'menu']),
+            ('Percorsi Tematici',['/video/percorsi','menu'])]
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    action = 'peliculas'
+    if 'epoche' in item.url:
+        patronMenu =r'<li>\s*<a href="(?P<url>[^"]+)">(?P<title>[^>]+)<'
+    elif 'percorsi' in item.url:
+        patron = r'<div class="cover_percorso">\s*<a href="(?P<url>[^"]+)">\s*<img src="(?P<thumb>[^"]+)"[^>]+>\s*[^>]+>(?P<title>.*?)<'
+    else:
+        patron = r'<h2>\s*<a href="(?P<url>[^,"]+),[^"]+"\s*>(?P<title>[^<]+)<'
+        patronNext = r'<div class="dx">\s*<a href="(.*?)">pagina suc'
+    return locals()
+
+
+def search(item, text):
+    support.info(text)
+    item.args = 'noorder'
+    item.url = host + '/ricerca/type_ALL/ricerca_' + text
+    item.contentType = 'movie'
+    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 peliculas(item):
+    if 'alfabetico' in item.url:
+        patron = r'<img src="(?P<thumb>[^"]+)"[^>]+>\s*[^>]+>\s*<div[^>]+>\s*<div[^>]+>[^>]+>\s*<a href="(?P<url>[^"]+)"[^>]+>(?:\[)?(?P<title>[^\]<]+)(?:\]|<)'
+    else:
+        if 'type_ALL' in item.url: patronBlock = r'Video:(?P<block>.*?)(?:<div class=""|<!--)'
+        elif not 'NomePersona' in item.url: patronBlock = r'<h3>Film</h3>(?P<block>.*?)<div class="list_wrapper'
+        patron = r'<a href="(?P<url>[^"]+)"\s*class="[^"]+"\s*title="(?:\[)?(?P<title>[^\]"]+)(?:\])?"\s*rel="(?P<thumb>[^"]+)"'
+    patronNext = r'<div class="dx">\s*<a href="(.*?)">pagina suc'
+    return locals()
+
+
+def findvideos(item):
+    support.info()
+    itemlist = []
+
+    matches = support.match(item, patron=r'filename: "(.*?)"').matches
+
+    for url in matches:
+        itemlist.append(item.clone(action="play", title=support.config.get_localized_string(30137), server='directo', url=host + url))
+
+    return support.server(item, itemlist=itemlist)
+

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.json

@@ -0,0 +1,12 @@
+{
+    "id": "discoveryplus",
+    "name": "Discovery + [free]",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "discoveryplus.png",
+    "banner": "discoveryplus.png",
+    "categories": ["tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": []
+}

channels/discoveryplus.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Rai Play
+# ------------------------------------------------------------
+import functools
+
+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
+
+# 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,
+                   '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}', ['', 'programs', 'programmi'])]
+
+    search = ''
+
+    return locals()
+
+
+def search(item, text):
+    itemlist = []
+
+    item.text = text
+
+    try:
+        itemlist = peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error(line)
+
+    return itemlist
+
+
+def live(item):
+    logger.debug()
+
+    itemlist =[]
+    # 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):
+    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 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(key['attributes']['name'],'bold'),
+                           plot=key['attributes'].get('description',''),
+                           programid=key['attributes']['alternateId'],
+                           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 =[]
+    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 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',
+                                       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'))]
+
+    return itemlist
+
+
+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 ="{}|PreAuthorization={}|R{{SSM}}|".format(data['streaming'][0]['protection']['schemes']['widevine']['licenseUrl'],
+	                      data['streaming'][0]['protection']['drmToken'])
+    else:
+        item.url = data['streaming'][0]['url']
+        item.manifest = 'hls'
+
+    return support.server(item, itemlist=[item], Download=False, Videolibrary=False)

channels/dreamsub.json

@@ -0,0 +1,10 @@
+{
+    "id": "dreamsub",
+    "name": "DreamSub",
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "dreamsub.png",
+    "banner": "dreamsub.png",
+    "categories": ["anime", "vos"],
+    "settings": []
+}

channels/dreamsub.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'dreamsub'
+# ------------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    support.info(item)
+
+    anime = ['/search?typeY=tv',
+            ('Movie', ['/search?typeY=movie', 'peliculas', '', 'movie']),
+            ('OAV', ['/search?typeY=oav', 'peliculas', '', 'tvshow']),
+            ('Spinoff', ['/search?typeY=spinoff', 'peliculas', '', 'tvshow']),
+            ('Generi', ['','menu','Generi']),
+            ('Stato', ['','menu','Stato']),
+            ('Ultimi Episodi', ['', 'peliculas', ['last', 'episodiRecenti']]),
+            ('Ultimi Aggiornamenti', ['', 'peliculas', ['last', 'episodiNuovi']])
+             ]
+
+    return locals()
+
+
+@support.scrape
+def menu(item):
+    item.contentType = ''
+    action = 'peliculas'
+    
+
+    patronBlock = r'<div class="filter-header"><b>%s</b>(?P<block>.*?)<div class="filter-box">' % item.args
+    patronMenu = r'<a class="[^"]+" data-state="[^"]+" (?P<other>[^>]+)>[^>]+></i>[^>]+></i>[^>]+></i>(?P<title>[^>]+)</a>'
+
+    def itemHook(item):
+        support.info(item.type)
+        for Type, ID in support.match(item.other, patron=r'data-type="([^"]+)" data-id="([^"]+)"').matches:
+            item.url = host + '/search?' + Type + 'Y=' + ID
+        return item
+    return locals()
+
+
+def search(item, text):
+    support.info(text)
+
+    text = text.replace(' ', '+')
+    item.url = host + '/search/' + 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('search log:', line)
+        return []
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    try:
+        if categoria == "anime":
+            item.url = host
+            item.args = ['last', 'episodiNuovi']
+            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 []
+
+
+
+@support.scrape
+def peliculas(item):
+    # debug = True
+    anime = True
+    if 'movie' in item.url:
+        item.contentType = 'movie'
+        action = 'findvideos'
+    else:
+        item.contentType = 'tvshow'
+        action = 'episodios'
+
+    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>[^"]+)"'
+    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="([^"]+)">'
+
+    def itemHook(item):
+        if item.thumbnail and not item.thumbinail.startswith('http'):
+            item.thumbnail = 'http://' + item.thumbnail
+        return item
+
+    return locals()
+
+
+@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\s+href="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+)<'
+
+    return locals()
+
+
+def findvideos(item):
+    itemlist = []
+    support.info()
+    # support.dbg()
+
+    matches = support.match(item, patron=r'href="([^"]+)"', patronBlock=r'<div style="white-space: (.*?)<div id="main-content"')
+
+    if not matches.matches and item.contentType != 'episode':
+        item.data = matches.data
+        item.contentType = 'tvshow'
+        return episodios(item)
+
+    if 'vvvvid' in matches.data:
+        itemlist.append(item.clone(action="play", title='VVVVID', url=support.match(matches.data, patron=r'(http://www.vvvvid[^"]+)').match, server='vvvvid'))
+    else:
+        support.info('VIDEO')
+        for url in matches.matches:
+            lang = url.split('/')[-2]
+            if 'ita' in lang.lower():
+                language = 'ITA'
+            if 'sub' in lang.lower():
+                language = 'Sub-' + language
+            quality = url.split('/')[-1].split('?')[0]
+            url += '|User-Agent=' + support.httptools.get_user_agent() + '&Referer=' + url
+
+            itemlist.append(item.clone(action="play", title='', url=url, contentLanguage = language, quality = quality, order = quality.replace('p','').zfill(4), server='directo',))
+    return support.server(item, itemlist=itemlist)
+

channels/eurostreaming.json

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

channels/eurostreaming.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Eurostreaming
+# by Greko
+# ------------------------------------------------------------
+
+from core import support
+from core.item import Item
+
+# def findhost(url):
+#     permUrl = httptools.downloadpage(url, follow_redirects=False, only_headers=True).headers
+#     host = 'https://'+permUrl['location'].replace('https://www.google.it/search?q=site:', '')
+#     return host
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    support.info()
+    tvshow = []
+    anime = ['/category/anime-cartoni-animati/']
+    mix = [('Aggiornamenti {bullet bold} {TV}', ['/aggiornamento-episodi-nuovi/', 'peliculas', 'newest']),
+           ('Archivio {bullet bold} {TV}', ['/category/serie-tv-archive/', 'peliculas'])]
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # debug = True
+    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>[^"]+)"[^>]*>\s+?(?P<episode>\d+[×x]\d+-\d+|\d+[×x]\d+) (?P<title2>[^<\(]+)\s?\(?(?P<lang>SUB ITA)?\)?</a>'
+        pagination = ''
+    else:
+        patron = r'<div class="post-thumb">.*?<img src="(?P<thumb>[^"]+)".*?><a href="(?P<url>[^"]+)"[^>]+>(?P<title>.+?)\s?(?: Serie Tv)?\s?\(?(?P<year>\d{4})?\)?<\/a><\/h2>'
+        patronNext=r'a class="next page-numbers" href="?([^>"]+)">Avanti &raquo;</a>'
+
+    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+)&#215;(?P<episode>\d+)(</strong>)*(?P<title>.*?)<(?P<other>.*?br/>)'
+
+    def itemHook(i):
+        i.url = item.url
+        return i
+
+    return locals()
+
+
+def search(item, texto):
+    support.info()
+
+    item.url = "%s/?s=%s" % (host, 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-nuovi/" % 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.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/filmpertutti.json

@@ -0,0 +1,10 @@
+{
+  "id": "filmpertutti",
+  "name": "Filmpertutti",
+  "active": true,
+  "language": ["ita", "sub-ita"],
+  "thumbnail": "filmpertutti.png",
+  "banner": "filmpertutti.png",
+  "categories": ["anime", "tvshow","movie"],
+  "settings": []
+}

channels/filmpertutti.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per filmpertutti.py
+# ------------------------------------------------------------
+
+from core import httptools, support, scrapertools
+from core.item import Item
+from platformcode import config, logger
+
+def findhost(url):
+    page = httptools.downloadpage(url).data
+    url = support.scrapertools.find_single_match(page, 'Il nuovo indirizzo di FILMPERTUTTI è ?<a href="([^"]+)')
+    return url
+
+host = config.get_channel_url(findhost)
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+
+    film = ['/category/film/feed/',
+            ('Film al cinema', ['/category/ora-al-cinema/feed/', 'peliculas']),
+            ('Generi', ['/', 'genres']),
+            ('Saghe', ['/', 'genres', 'saghe']),
+           ]
+
+    tvshow = ['/category/serie-tv/feed/',
+             ]
+ 
+    anime = ['/category/anime/feed/',
+             ('SUB-ITA',['/category/anime-sub-ita/feed/', 'peliculas']),
+             ]
+
+    search = ''
+    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
+
+        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:
+                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()
+
+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],
+                                   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):
+    action = 'peliculas'
+    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 check(item):
+    item.data = httptools.downloadpage(item.url).data
+    if 'season-details' in item.data.lower():
+        item.contentType = 'tvshow'
+        return episodios(item)
+    else:
+        item.contentType = 'movie'
+        return findvideos(item)
+
+
+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 newest(categoria):
+    support.info()
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == "peliculas":
+            item.url = host + "/category/film/feed/"
+            item.action = "peliculas"
+            item.extra = "movie"
+            item.contentType = 'movie'
+            itemlist = peliculas(item)
+        else:
+            item.url = host + "/category/serie-tv/feed/"
+            item.action = "peliculas"
+            item.args = "newest"
+            item.contentType = 'tvshow'
+            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):
+    video_url = item.url
+
+    if item.contentType == 'movie':
+        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

@@ -0,0 +1,11 @@
+{
+    "id": "guardaseriecam",
+    "name": "GuardaSerie Cam",
+    "language": ["ita", "sub-ita"],
+    "active": true,
+    "thumbnail": "https://raw.githubusercontent.com/32Dexter/DexterRepo/master/media/guardaserie_live.png",
+    "banner": "",
+    "categories": ["tvshow"],
+    "not_active": ["include_in_newest"],
+    "settings": []
+}

channels/guardaseriecam.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'guardaserie_live'
+# By: Napster32
+# ------------------------------------------------------------
+# Rev: 0.0
+# Update 11-06-2020
+# fix:
+# 1. Emissione
+
+# possibilità di miglioramento: inserire menu per genere - lista serie tv e gestire le novità
+
+from core import support
+from core.support import info
+from platformcode import logger, config
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    tvshow = ['/serietv-streaming',
+              ('Per Lettera', ['/serietv-streaming/A', 'list', 'Serie-Tv per Lettera'])
+              ]
+    return locals()
+
+
+@support.scrape
+def list(item):
+    patronMenu = r'<a title="(?P<title>[^"]+)" href="(?P<url>[^"]+)'
+    action = 'peliculas'
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # 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>.*?)</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()
+
+
+def search(item, text):
+    support.info('search', text)
+    item.contentType = 'tvshow'
+    itemlist = []
+    text = text.replace(' ', '+')
+    item.url = host + '/index.php?story=%s&do=search&subaction=search' % (text)
+    try:
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            info('search log:', line)
+        return []
+
+
+def findvideos(item):
+    logger.debug()
+    return support.server(item, item.data)

channels/guardaserieclick.json

@@ -0,0 +1,29 @@
+{
+    "id": "guardaserieclick",
+    "name": "GuardaSerie.click",
+    "active": false,
+    "language": ["ita", "vos"],
+    "thumbnail": "guardaserieclick.png",
+    "bannermenu": "guardaserieclick.png",
+    "categories": ["tvshow", "anime"],
+    "not_active": ["include_in_newest_peliculas", "include_in_newest_anime"],
+    "settings": [
+		{
+		  "id": "include_in_newest_peliculas",
+		  "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
+		}
+    ],
+	"cloudflare": true
+}

channels/guardaserieclick.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per guardaserieclick
+# ------------------------------------------------------------
+
+"""
+
+    Avvisi per il test:
+        - Le voci del menu le trovi in "lista serie" del sito, e Generi = Sfoglia
+        - SE capita che entrando in una voce trovi "nessun elemento" torna indietro e rientra nella voce.
+        - Tutte le voci, tranne: Anime/Cartoni, mostrano per ogni pagina, al max 25 titoli
+
+    Presente in NOVITà:
+        - Serietv
+"""
+
+from core import support
+from core.item import Item
+from platformcode import config
+from core.support import info
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    tvshow = ['',
+              ('Aggiornamenti', ['', 'peliculas', 'update']),
+              ('Generi', ['', 'genres', 'genres']),
+              ('News Sub-ITA', ['', 'peliculas', 'ined']),
+              ('Anime/Cartoni', ["/category/animazione/", 'peliculas', 'genres'])
+              ]
+
+    return locals()
+
+
+##@support.scrape
+##def peliculas(item):
+####    import web_pdb; web_pdb.set_trace()
+##    info('peliculas ->\n', item)
+##
+##    action = 'episodios'
+##    block = r'(?P<block>.*?)<div\s+class="btn btn-lg btn-default btn-load-other-series">'
+##
+##    if item.args == 'ined':
+##        deflang = 'SUB-ITA'
+##        patronBlock = r'<span\s+class="label label-default label-title-typology">'+block
+##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+##        pagination = 25
+##    elif item.args == 'update':
+##        patronBlock = r'<div\s+class="container-fluid greybg title-serie-lastep title-last-ep fixed-title-wrapper containerBottomBarTitle">'+block
+##        patron = r'<a(?: rel="[^"]+")? href="(?P<url>[^"]+)"(?: class="[^"]+")?>[ ]<img class="[^"]+"[ ]title="[^"]+"[ ]alt="[^"]+"[ ]src="(?P<thumb>[^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<episode>\d+.\d+)[ ]\((?P<lang>[a-zA-Z\-]+)[^<]+<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>[^<]+)<'
+##    elif item.args == 'genres':
+##        patronBlock = r'<h2 style="color: white !important" class="title-typology">(?P<block>.+?)<div class="container-fluid whitebg" style="">'
+##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>[^<]+)</p>'
+##        patronNext = r'rel="next" href="([^"]+)">'
+##        item.contentType = 'tvshow'
+##    elif item.args == 'nolost':
+##        patronBlock = r'<h2 class="title-typology styck-top" meta-class="title-serie-danonperd">'+block
+##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+##        pagination = 25
+##    elif item.args == 'classic':
+##        patronBlock = r'<h2 class="title-typology  styck-top" meta-class="title-serie-classiche">'+block
+##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+##        pagination = 25
+##    else:
+##        patronBlock = r'<div\s+class="container container-title-serie-new container-scheda" meta-slug="new">'+block
+##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+##        pagination = 25
+##
+##    debug = True
+##    return locals()
+
+@support.scrape
+def peliculas(item):
+    ##    import web_pdb; web_pdb.set_trace()
+    info('peliculas ->\n', item)
+
+    action = 'episodios'
+    blacklist = ['DMCA']
+
+    if item.args == 'genres' or item.args == 'search':
+        patronBlock = r'<h2 style="color:\s?white !important;?" class="title-typology">(?P<block>.+?)<div class="container-fluid whitebg" style="">'
+        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>[^<]+)</p>'
+        patronNext = r'rel="next" href="([^"]+)">'
+        item.contentType = 'tvshow'
+    ##    elif item.args == 'search':
+    ##        patronBlock = r'<h2 style="color:\s?white !important.?" class="title-typology">(?P<block>.*?)<div class="container-fluid whitebg" style="">'
+    ##        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>[^<]+)</p>'
+    else:
+        end_block = r'(?P<block>.*?)<div\s+class="btn btn-lg btn-default btn-load-other-series">'
+        patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+        pagination = 25
+        if item.args == 'ined':
+            deflang = 'SUB-ITA'
+            patronBlock = r'<span\s+class="label label-default label-title-typology">' + end_block
+        ##            patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+        ##            pagination = 25
+        elif item.args == 'update':
+            patronBlock = r'<div\s+class="container-fluid greybg title-serie-lastep title-last-ep fixed-title-wrapper containerBottomBarTitle">' + end_block
+            patron = r'href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>.+?class="strongText">(?P<title>.+?)<'
+        # elif item.args == 'nolost':
+        #     patronBlock = r'<h2 class="title-typology styck-top" meta-class="title-serie-danonperd">' + end_block
+        #            pagination = 25
+        # elif item.args == 'classic':
+        #     patronBlock = r'<h2 class="title-typology  styck-top" meta-class="title-serie-classiche">' + end_block
+        ##            patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+        ##            pagination = 25
+        ##        elif item.args == 'anime':
+        ##
+        else:
+            patronBlock = r'<div\s+class="container container-title-serie-new container-scheda" meta-slug="new">' + end_block
+    ##            patron = r'<a href="(?P<url>[^"]+)".*?>\s<img\s.*?src="(?P<thumb>[^"]+)"\s/>[^>]+>[^>]+>\s[^>]+>\s(?P<year>\d{4})?\s.+?class="strongText">(?P<title>.+?)<'
+    ##            pagination = 25
+    # support.regexDbg(item, patronBlock, headers)
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    info()
+
+    action = 'findvideos'
+    patron = r'<div class="number-episodes-on-img">\s?\d+.\d+\s?(?:\((?P<lang>[a-zA-Z\-]+)\))?</div>.+?(?:<span class="pull-left bottom-year">(?P<title2>[^<]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<plot>[^<]+)<[^>]+>[^>]+>[^>]+>\s?)?<span(?: meta-nextep="[^"]+")? class="[^"]+" meta-serie="(?P<title>[^"]+)" meta-stag="(?P<season>\d+)" meta-ep="(?P<episode>\d+)" meta-embed="(?P<url>[^>]+)">'
+    patronBlock = r'<h2 class="title-typology">Episodi (?P<stagione>\d+).{1,3}Stagione</h2>(?P<block>.*?)<div class="container">'
+
+    def itemHook(item):
+        item.title = item.title.replace(item.fulltitle, '').replace('-', '', 1)
+        return item
+
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    info()
+
+    action = 'peliculas'
+    patronMenu = r'<li>\s<a\shref="(?P<url>[^"]+)"[^>]+>(?P<title>[^<]+)</a></li>'
+    patron_block = r'<ul\sclass="dropdown-menu category">(?P<block>.*?)</ul>'
+    # debug = True
+    return locals()
+
+
+def search(item, text):
+    info(text)
+    item.url = host + "/?s=" + text
+    item.contentType = 'tvshow'
+    item.args = 'search'
+    try:
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("%s" % line)
+        return []
+
+
+def newest(categoria):
+    info()
+    itemlist = []
+    item = Item()
+    item.contentType = 'tvshow'
+    item.args = 'update'
+    try:
+        if categoria == "series":
+            item.url = host
+            item.action = "peliculas"
+            itemlist = peliculas(item)
+
+    # Continua la ricerca in caso di errore
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("{0}".format(line))
+        return []
+
+    return itemlist
+
+
+def findvideos(item):
+    info('--->', item)
+    return support.server(item, item.url)

channels/guardaserieicu.json

@@ -0,0 +1,11 @@
+{
+    "id": "guardaserieicu",
+    "name": "Guarda Serie Icu",
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "https://raw.githubusercontent.com/32Dexter/DexterRepo/master/media/guarda_serie.jpg",
+    "banner": "",
+    "categories": ["tvshow"],
+    "not_active": ["include_in_newest"],
+    "settings": []
+}

channels/guardaserieicu.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per 'Guarda_Serie'
+# By: Napster32
+# ------------------------------------------------------------
+# Rev: 0.0
+# Update 11-06-2020
+# fix:
+# 1. Emissione
+
+# possibilità di miglioramento: gestire le novità (sezione Ultimi episodi sul sito)
+
+from core.support import info
+from core import support
+from platformcode import config
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    tvshow = ['/serie']
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # 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'
+    item.url = host + "/?s=" + text
+    try:
+        item.args = 'search'
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("%s" % line)
+
+    return []
+
+
+def findvideos(item):
+    support.info('findvideos', item)
+    data = support.match(item, headers=headers, patron=r'div class="movieplay">([^>]+)').matches
+    return support.server(item, data=data )

channels/hd4me.json

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

channels/hd4me.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per HD4ME
+# ------------------------------------------------------------
+
+from core import support
+
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+
+    film = [('Genere', ['', 'genre'])]
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # debug = True
+    if item.args == 'alternative':
+        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>[^"]+)'
+        patronNext = r'current(?:[^>]*>){2}\s*<a class="[^"]+"\s* href="([^"]+)'
+    return locals()
+
+
+@support.scrape
+def genre(item):
+    action = 'peliculas'
+    blacklist =['prova ']
+    patronMenu = r'<a href="(?P<url>[^"]+)" class="menu-link\s*sub-menu-link">(?P<title>[^<]+)<'
+    def itemHook(item):
+        if item.fulltitle in ['Classici Disney', 'Studio Ghibli', 'Pixar']:
+            item.args = 'alternative'
+        return item
+    return locals()
+
+
+def search(item, text):
+    support.info(text)
+    item.url = host + '/?s=' + 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: %s" % line)
+        return []
+
+
+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.json

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

channels/ilcorsaronero.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# 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
+
+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]])
+    ]
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # debug = True
+    action = 'findvideos'
+    sceneTitle = item.args[2]
+    if item.args[1] in ['tvshow', 'anime', 'music', 'other']:
+        patron = r'>[^"<]+'
+    else:
+        patron = r'>(?P<quality>[^"<]+)'
+    patron += '<td[^>]+><a class="tab" href="(?P<url>[^"]+)"\s*>[^<]+<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<size>[^<]+)<[^>]+>[^>]+>[^>]+><form action="[^"]+/\d+/(?P<title>[^"]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<seed>[^<]+)'
+
+    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
+
+    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
+    return locals()
+
+
+def search(item, text):
+    support.info(item, text)
+    if 'all' in item.args:
+        item.url += text
+    else:
+        item.url += text + '.html'
+    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)
+        return []
+
+
+def findvideos(item):
+    if item.contentType == 'tvshow': item.contentType = 'episode'
+    Videolibrary = True if 'movie' in item.args else False
+    return support.server(item, support.match(item.url, patron=r'"(magnet[^"]+)').match, Videolibrary=Videolibrary)

channels/ilgeniodellostreaming.json

@@ -0,0 +1,10 @@
+{
+    "id": "ilgeniodellostreaming",
+    "name": "IlGenioDelloStreaming",
+    "active": false,
+    "language": ["ita", "sub-ita"],
+    "thumbnail": "ilgeniodellostreaming.png",
+    "banner": "ilgeniodellostreaming.png",
+    "categories": ["movie", "tvshow", "anime", "vos"],
+    "settings": ["include_in_newest_anime"]
+}

channels/ilgeniodellostreaming.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+#
+# Canale per ilgeniodellostreaming
+# ------------------------------------------------------------
+
+
+from core import support
+from core.support import info
+from core.item import Item
+from platformcode import config
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    support.info(item)
+
+    film = ['/film/',
+        ('Generi',['', 'genres', 'genres']),
+        ('Per Lettera',['/film-a-z/', 'genres', 'letter']),
+        ('Anni',['', 'genres', 'year']),
+        ('Popolari',['/trending/?get=movies', 'peliculas', 'populared']),
+        ('Più Votati', ['/ratings/?get=movies', 'peliculas', 'populared'])
+        ]
+
+    tvshow = ['/serie/',
+        ('Aggiornamenti', ['/aggiornamenti-serie/', 'peliculas', 'update']),
+        ('Popolari',['/trending/?get=tv', 'peliculas', 'populared']),
+        ('Più Votati', ['/ratings/?get=tv', 'peliculas', 'populared'])
+
+        ]
+
+    anime = ['/anime/'
+        ]
+
+    Tvshow = [
+        ('Show TV {bullet bold}', ['/tv-show/', 'peliculas', '', 'tvshow'])
+        ]
+
+    search = ''
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    info()
+    # debugBlock = True
+    # debug=True
+
+    if item.args == 'search':
+        patronBlock = r'<div class="search-page">(?P<block>.*?)<footer class="main">'
+        patron = r'<img src="(?P<thumb>[^"]+)" alt="[^"]+" ?/?>[^>]+>(?P<type>[^<]+)</span>.*?<a href="(?P<url>[^"]+)">(?P<title>.+?)[ ]?(?:\[(?P<lang>Sub-ITA)\])?</a>[^>]+>[^>]+>(?:<span class="rating">IMDb\s*(?P<rating>[^>]+)</span>)?.?(?:<span class="year">(?P<year>[0-9]+)</span>)?.*?<p>(?P<plot>.*?)</p>'
+
+        typeContentDict={'movie': ['film'], 'tvshow': ['tv']}
+        typeActionDict={'findvideos': ['film'], 'episodios': ['tv']}
+    else:
+
+        if item.contentType == 'movie':
+            endBlock = '</article></div>'
+        else:
+            endBlock = '<footer class="main">'
+
+        patronBlock = r'<header><h1>.+?</h1>(?P<block>.*?)'+endBlock
+
+        if item.contentType == 'movie':
+            if item.args == 'letter':
+                patronBlock = r'<table class="table table-striped">(?P<block>.+?)</table>'
+                patron = r'<img src="(?P<thumb>[^"]+)"[^>]+>[^>]+>[^>]+><td class="mlnh-2"><a href="(?P<url>[^"]+)">(?P<title>.+?)[ ]?(?:\[(?P<lang>Sub-ITA)\])?<[^>]+>[^>]+>[^>]+>(?P<year>\d{4})\s+<'
+            elif item.args == 'populared':
+                patron = r'<img src="(?P<thumb>[^"]+)" alt="[^"]+">[^>]+>[^>]+>[^>]+>[^>]+>\s+?(?P<rating>\d+.?\d+|\d+)<[^>]+>[^>]+>(?P<quality>[a-zA-Z\-]+)[^>]+>[^>]+>[^>]+>[^>]+><a href="(?P<url>[^"]+)">(?P<title>[^<]+)<[^>]+>[^>]+>[^>]+>(?P<year>\d+)<'
+            else:
+
+                #patron = r'<div class="poster">\s*<a href="(?P<url>[^"]+)"><img src="(?P<thumb>[^"]+)" alt="[^"]+"><\/a>[^>]+>[^>]+>[^>]+>\s*(?P<rating>[0-9.]+)<\/div><span class="quality">(?:SUB-ITA|)?(?P<quality>|[^<]+)?<\/span>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>.+?)[ ]?(?:\[(?P<lang>Sub-ITA)\])?<\/a>[^>]+>[^>]+>(?P<year>[^<]+)<\/span>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<plot>[^<]+)<div'
+                patron = r'<div class="poster">\s?<a href="(?P<url>[^"]+)"><img src="(?P<thumb>[^"]+)" alt="[^"]+"><\/a>[^>]+>[^>]+>[^>]+>\s*(?P<rating>[0-9.]+)<\/div>(?:<span class="quality">(?:SUB-ITA|)?(?P<quality>|[^<]+)?<\/span>)?[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>.+?)[ ]?(?:\[(?P<lang>Sub-ITA)\])?<\/a>[^>]+>[^>]+>(?P<year>[^<]+)<\/span>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<plot>[^<]+)<div'
+        else:
+            # TVSHOW
+            action = 'episodios'
+            if item.args == 'update':
+                action = 'findvideos'
+                patron = r'<div class="poster"><img src="(?P<thumb>[^"]+)"(?:[^>]+>){2}<a href="(?P<url>[^"]+)">[^>]+>(?P<episode>[\d\-x]+)(?:[^>]+>){4}(?P<title>.+?)(?:\[(?P<lang>[SsuUbBiItTaA-]{7})\])?<(?:[^>]+>){4}(?P<quality>[HDWEBRIP-]+)?(?:.+?)?/span><p class="serie"'
+                pagination = 25
+                def itemHook(item):
+                    item.contentType = 'episode'
+                    return item
+            else:
+                patron = r'<div class="poster">\s?<a href="(?P<url>[^"]+)"><img src="(?P<thumb>[^"]+)" alt="[^"]+"><\/a>[^>]+>[^>]+>[^>]+> (?P<rating>[0-9.]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<title>.+?)[ ]?(?:\[(?P<lang>Sub-ITA|Sub-ita)\])?<[^>]+>[^>]+>[^>]+>(?P<year>[0-9]{4})?[^<]*(?:<.*?<div class="texto">(?P<plot>[^<]+)?)?'
+    patronNext = '<span class="current">[^<]+<[^>]+><a href=[\'"]([^\'"]+)[\'"]'
+
+    #support.regexDbg(item, patron, headers)
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    info()
+
+    patronBlock = r'<h1>.*?[ ]?(?:\[(?P<lang>.+?\]))?</h1>.+?<div class="se-a" style="display:block">\s*<ul class="episodios">(?P<block>.*?)</ul>\s*</div>\s*</div>\s*</div>\s*</div>\s*</div>'
+    patron = r'<a href="(?P<url>[^"]+)"><img src="(?P<thumb>[^"]+)">.*?'\
+             '<div class="numerando">(?P<episode>[^<]+).*?<div class="episodiotitle">'\
+             '[^>]+>(?P<title>[^<]+)<\/a>'
+    # debugBlock = True
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    info(item)
+
+    action='peliculas'
+    if item.args == 'genres':
+        patronBlock = r'<div class="sidemenu"><h2>Genere</h2>(?P<block>.*?)/li></ul></div>'
+    elif item.args == 'year':
+        item.args = 'genres'
+        patronBlock = r'<div class="sidemenu"><h2>Anno di uscita</h2>(?P<block>.*?)/li></ul></div>'
+    elif item.args == 'letter':
+        patronBlock = r'<div class="movies-letter">(?P<block>.*?)<div class="clearfix">'
+
+    patronMenu = r'<a(?:.+?)?href="(?P<url>.*?)"[ ]?>(?P<title>.*?)<\/a>'
+    # debugBlock = True
+
+    return locals()
+
+
+def search(item, text):
+    info(text)
+    import uuid
+    text = text.replace(' ', '+')
+    item.url = host + '/?' + uuid.uuid4().hex + '=' + uuid.uuid4().hex + '&s=' + text
+    try:
+        item.args = 'search'
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("%s" % line)
+
+    return []
+
+def newest(categoria):
+    info(categoria)
+    itemlist = []
+    item = Item()
+
+    if categoria == 'peliculas':
+        item.contentType = 'movie'
+        item.url = host + '/film/'
+    elif categoria == 'series':
+        item.args = 'update'
+        item.contentType = 'tvshow'
+        item.url = host + '/aggiornamenti-serie/'
+##    elif categoria == 'anime':
+##        item.contentType = 'tvshow'
+##        item.url = host + '/anime/'
+    try:
+        item.action = 'peliculas'
+        itemlist = peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("{0}".format(line))
+        return []
+
+    return itemlist
+
+
+def findvideos(item):
+    info()
+    matches = support.match(item, patron=[r'var ilinks\s?=\s?([^;]+)',r' href="#option-\d">([^\s]+)\s*([^\s]+)']).matches
+    itemlist = []
+    list_url = []
+    list_quality = []
+    list_servers = []
+    for match in matches:
+        if type(match) == tuple:
+            list_servers.append(match[0])
+            list_quality.append(match[1])
+        else:
+            import ast, base64
+            encLinks = ast.literal_eval(match)
+
+            for link in encLinks:
+                linkDec = base64.b64decode(link.encode()).decode()
+                if 'player.php' in linkDec:
+                    linkDec = support.httptools.downloadpage(linkDec, only_headers=True, follow_redirects=False).headers.get('Location')
+                if linkDec:
+                    list_url.append(linkDec)
+    if list_servers:
+        for i, url in enumerate(list_url):
+            itemlist.append(support.Item(
+                    channel=item.channel,
+                    title=list_servers[i],
+                    url=url,
+                    action='play',
+                    quality=list_quality[i],
+                    infoLabels=item.infoLabels))
+
+    return support.server(item, itemlist=itemlist)

channels/ilgeniodellostreaming_cam.json

@@ -0,0 +1,10 @@
+{
+    "id": "ilgeniodellostreaming_cam",
+    "name": "IlGenioDelloStreaming CAM",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "ilgeniodellostreaming.png",
+    "banner": "ilgeniodellostreaming.png",
+    "categories": ["movie"],
+    "settings": []
+}

channels/ilgeniodellostreaming_cam.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per ilgeniodellostreaming_cam
+# ------------------------------------------------------------
+
+
+from core import support
+from core.support import info
+from core.item import Item
+from platformcode import config
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+@support.menu
+def mainlist(item):
+    film = ['/film/',
+           ('In Sala', ['', 'peliculas', 'sala']),
+           ('Generi',['', 'genres', 'genres']),
+           ('Per Lettera',['/catalog/all', 'genres', 'az']),
+           ('Anni',['', 'genres', 'year'])]
+
+    return locals()
+
+
+@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})'
+        elif item.args == 'az':
+            patron = r'<img src="(?P<thumb>[^"]+)[^>]+>[^>]+>[^>]+>[^>]+><a href="(?P<url>[^"]+)[^>]+>(?P<title>[^<]+)<[^>]+>[^>]+>[^>]+>.*?<span class="labelimdb">(?P<rating>[^>]+)<'
+        else:
+            patron = r'<img src="(?P<thumb>[^"]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(?P<rating>[^<]+)[^>]+>[^>]+>(?P<quality>[^<]+)[^>]+>[^>]+>[^>]+>[^>]+><a href="(?P<url>[^"]+)">(?P<title>[^<]+)[^>]+>[^>]+>[^>]+>(?P<year>\d{4})[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(?P<plot>[^<]+)<[^>]+>'
+
+        patronNext = 'href="([^>]+)">»'
+
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    action='peliculas'
+    if item.args == 'genres':
+        patronBlock = r'<div class="sidemenu">\s*<h2>Genere</h2>(?P<block>.*?)</ul'
+    elif item.args == 'year':
+        item.args = 'genres'
+        patronBlock = r'<div class="sidemenu">\s*<h2>Anno di uscita</h2>(?P<block>.*?)</ul'
+    elif item.args == 'az':
+        patronBlock = r'<div class="movies-letter">(?P<block>.*?)<div class="clearfix">'
+
+    patronMenu = r'<a(?:.+?)?href="(?P<url>.*?)"[ ]?>(?P<title>.*?)<\/a>'
+
+    return locals()
+
+def search(item, text):
+    info(text)
+    item.text = text
+    try:
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("%s" % line)
+
+    return []
+
+def newest(categoria):
+    info(categoria)
+    itemlist = []
+    item = Item()
+
+    if categoria == 'peliculas':
+        item.contentType = 'movie'
+        item.url = host + '/film/'
+    try:
+        item.action = 'peliculas'
+        itemlist = peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            info("{0}".format(line))
+        return []
+
+    return itemlist
+
+
+def findvideos(item):
+    info()
+    urls = []
+    data = support.match(item).data
+    urls += support.match(data, patron=r'id="urlEmbed" value="([^"]+)').matches
+    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/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

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

channels/italiaserie.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per italiaserie
+# ------------------------------------------------------------
+
+
+from core import support, httptools, scrapertools
+from core.item import Item
+from platformcode import config, logger
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    tvshow = ['',
+        ('Aggiornamenti', ['/aggiornamento-episodi/', 'peliculas', 'update']),
+        ('Top 10', ['/top-10', 'peliculas', 'top']),
+        ('Netflix {tv submenu}', ['/genere/netflix', 'peliculas'])
+        ]
+
+    return locals()
+
+
+@support.scrape
+def peliculas(item):
+    # debug=True
+    blacklist = ['Aggiornamento Episodi']
+    action = 'episodios'
+    patron = r'<div class="post-thumb">\s*<a href="(?P<url>[^"]+)" title="(?P<title>[^"\[]+)[^>]+>\s*<img src="(?P<thumb>[^"]+)"[^>]+>'
+
+    if item.args == 'update':
+        pagination = ''
+        #patron = r'br />(?:[^>]+>)?(?P<title>[^–]+)[^<]+<a href="(?P<url>[^"]+)">(?P<episode>[^ ]+)\s*(?P<title2>[^\(<]+)(?:\((?P<lang>[^\)]+))?'
+        patron = r'br[\s/]*>(?:\s*<[^>]+>)*(?P<title>[^–<]+)[^<]+<a href="(?P<url>[^"]+)"[^>]*>(?:[^,]{0,80}[, ]{2})*(?P<episode>[\S]+)\s*(?P<title2>[^\(<]+)(?:\((?P<lang>[^\)]+))?'
+        action = 'episodios'
+    if item.args == 'top':
+        patron = r'<a href="(?P<url>[^"]+)">(?P<title>[^<]+)</a>(?:[^>]+>){3}<img.*?src="(?P<thumb>[^"]+)"[^>]+>(?:[^>]+>){5}:\s*(?P<rating>[^/]+)'
+    if item.args =='a-z':
+        pagination = ''
+        patron = r'<li ><a href="(?P<url>[^"]+)" title="(?P<title>[^"]+)"'
+    patronNext = r'<a class="next page-numbers" href="(.*?)">'
+
+    def itemHook(item):
+        item.title = support.re.sub(r'<[^>]+>','', item.title)
+        return item
+
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    res = support.match(item, patron=r'<a href="([^"]+)">&gt;')
+    if res.match: data = support.match(res.match).data
+    else: data = res.data
+
+    patronBlock = r'(?:Stagione|STAGIONE)\s*(?P<lang>[^<]+)?(?:</p>)?(?P<block>.*?)</p>'
+    patron = r'(?:p>|/>)(?P<title>[^–]+)–(?P<data>.*?)(?:<br|$)'
+
+    def itemHook(item):
+        item.title = support.re.sub('<[^>]+>','', item.title)
+        return item
+    return locals()
+
+
+@support.scrape
+def category(item):
+    action = 'peliculas'
+    patron = r'<li class="cat-item.*?href="(?P<url>[^"]+)".*?>(?P<title>.*?)</a>'
+    return locals()
+
+
+def search(item, texto):
+    support.info("s=", texto)
+    item.url = host + "/?s=" + 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("%s" % line)
+        return []
+
+
+def newest(categoria):
+    support.info("newest", categoria)
+    itemlist = []
+    item = Item()
+    try:
+        if categoria == "series":
+            item.url = host + "/aggiornamento-episodi/"
+            item.action = "peliculas"
+            item.args = "update"
+            item.contentType = "episode"
+            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):
+    logger.debug()
+    data = support.match(item.data, patron=r'href="([^"]+)').matches
+    return support.server(item, data=data)

channels/la7.json

@@ -0,0 +1,13 @@
+{
+    "id": "la7",
+    "name": "La7",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "la7.png",
+    "banner": "la7.png",
+    "categories": ["movie", "tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": [],
+    "cloudflare": true
+}

channels/la7.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per La7
+# ------------------------------------------------------------
+
+import requests
+from core import support, httptools
+from platformcode import logger
+
+DRM = 'com.widevine.alpha'
+key_widevine = "https://la7.prod.conax.cloud/widevine/license"
+host = 'https://www.la7.it'
+headers = {
+    'host_token': 'pat.la7.it',
+    'host_license': 'la7.prod.conax.cloud',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36',
+    'accept': '*/*',
+    'accept-language': 'en,en-US;q=0.9,it;q=0.8',
+    'dnt': '1',
+    'te': 'trailers',
+    'origin': 'https://www.la7.it',
+    'referer': 'https://www.la7.it/',
+}
+
+@support.menu
+def mainlist(item):
+    top =  [('Dirette {bold}', ['', 'live']),
+            ('Replay {bold}', ['', 'replay_channels'])]
+
+    menu = [('Programmi TV {bullet bold}', ['/tutti-i-programmi', 'peliculas', '', 'tvshow']),
+            ('Teche La7 {bullet bold}', ['/la7teche', 'peliculas', '', 'tvshow'])]
+
+    search = ''
+    return locals()
+
+
+def live(item):
+    itemlist = [item.clone(title=support.typo('La7', 'bold'), fulltitle='La7', url= host + '/dirette-tv', action='findvideos', forcethumb = True, no_return=True),
+                item.clone(title=support.typo('La7d', 'bold'), fulltitle='La7d', url= host + '/live-la7d', action='findvideos', forcethumb = True, no_return=True)]
+    return support.thumb(itemlist, live=True)
+
+
+def replay_channels(item):
+    itemlist = [item.clone(title=support.typo('La7', 'bold'), fulltitle='La7', url= host + '/rivedila7/0/la7', action='replay_menu', forcethumb = True),
+                item.clone(title=support.typo('La7d', 'bold'), fulltitle='La7d', url= host + '/rivedila7/0/la7d', action='replay_menu', forcethumb = True)]
+    return support.thumb(itemlist, live=True)
+
+
+@support.scrape
+def replay_menu(item):
+    action = 'replay'
+    patron = r'href="(?P<url>[^"]+)"><div class="giorno-text">\s*(?P<day>[^>]+)</div><[^>]+>\s*(?P<num>[^<]+)</div><[^>]+>\s*(?P<month>[^<]+)<'
+    def itemHook(item):
+        item.title = support.typo(item.day + ' ' + item.num + ' ' + item.month,'bold')
+        return item
+    return locals()
+
+
+@support.scrape
+def replay(item):
+    action = 'findvideos'
+    patron = r'guida-tv"><[^>]+><[^>]+>(?P<hour>[^<]+)<[^>]+><[^>]+><[^>]+>\s*<a href="(?P<url>[^"]+)"><[^>]+><div class="[^"]+" data-background-image="(?P<t>[^"]+)"><[^>]+><[^>]+><[^>]+><[^>]+>\s*(?P<name>[^<]+)<[^>]+><[^>]+><[^>]+>(?P<plot>[^<]+)<'
+    def itemHook(item):
+        item.title = support.typo(item.hour + ' - ' + item.name,'bold')
+        item.contentTitle = item.fulltitle = item.show = item.name
+        item.thumbnail = 'http:' + item.t
+        item.fanart = item.thumbnail
+        item.forcethumb = True
+        return item
+    return locals()
+
+def search(item, text):
+    item.url = host + '/tutti-i-programmi'
+    item.search = text
+    try:
+        return peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.info('search log:', line)
+        return []
+
+
+@support.scrape
+def peliculas(item):
+    search = item.search
+    action = 'episodios'
+    pagination = 20
+    disabletmdb = True
+    addVideolibrary = False
+    downloadEnabled = False
+
+    patron = r'<a href="(?P<url>[^"]+)"[^>]+><div class="[^"]+" data-background-image="(?P<t>[^"]+)"></div><div class="titolo">\s*(?P<title>[^<]+)<'
+
+    if 'la7teche' in item.url:
+        patron = r'<a href="(?P<url>[^"]+)" title="(?P<title>[^"]+)" class="teche-i-img".*?url\(\'(?P<thumb>[^\']+)'
+
+    def itemHook(item):
+        item.fanart = item.thumb
+        return item
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    action = 'findvideos'
+    addVideolibrary = False
+    downloadEnabled = False
+
+    if 'la7teche' in item.url:
+        patron = r'<a href="(?P<url>[^"]+)">\s*<div class="holder-bg">.*?data-background-image="(?P<thumb>[^"]+)(?:[^>]+>){4}\s*(?P<title>[^<]+)(?:(?:[^>]+>){2}\s*(?P<plot>[^<]+))?'
+    else:
+        data = str(support.match(item.url, patron=r'"home-block home-block--oggi(.*?)</section>').matches)
+        data += httptools.downloadpage(item.url + '/video').data
+
+        patron = r'item[^>]+>\s*<a href="(?P<url>[^"]+)">.*?image="(?P<thumb>[^"]+)(?:[^>]+>){4,5}\s*(?P<title>[\d\w][^<]+)(?:(?:[^>]+>){7}\s*(?P<title2>[\d\w][^<]+))?'
+    patronNext = r'<a href="([^"]+)">›'
+    return locals()
+
+
+def findvideos(item):
+    support.info()
+    if item.livefilter:
+        for it in live(item):
+            if it.fulltitle == item.livefilter:
+                item = it
+                break
+    data = support.match(item).data
+
+    url = support.match(data, patron=r'''["]?dash["]?\s*:\s*["']([^"']+)["']''').match
+    if url:
+        preurl = support.match(data, patron=r'preTokenUrl = "(.+?)"').match
+        tokenHeader = {
+            'host': headers['host_token'],
+            'user-agent': headers['user-agent'],
+            'accept': headers['accept'],
+            'accept-language': headers['accept-language'],
+            'dnt': headers['dnt'],
+            'te': headers['te'],
+            'origin': headers['origin'],
+            'referer': headers['referer'],
+        }
+        preAuthToken = requests.get(preurl, headers=tokenHeader,verify=False).json()['preAuthToken']
+        licenseHeader = {
+            'host': headers['host_license'],
+            'user-agent': headers['user-agent'],
+            'accept': headers['accept'],
+            'accept-language': headers['accept-language'],
+            'preAuthorization': preAuthToken,
+            'origin': headers['origin'],
+            'referer': headers['referer'],
+        }
+        preLic= '&'.join(['%s=%s' % (name, value) for (name, value) in licenseHeader.items()])
+        tsatmp=str(int(support.time()))
+        license_url= key_widevine + '?d=%s'%tsatmp
+        lic_url='%s|%s|R{SSM}|'%(license_url, preLic)
+        item.drm = DRM
+        item.license = lic_url
+    else:
+        match = support.match(data, patron='/content/entry/data/(.*?).mp4').match
+        if match:
+            url = 'https://awsvodpkg.iltrovatore.it/local/hls/,/content/entry/data/' + support.match(item, patron='/content/entry/data/(.*?).mp4').match + '.mp4.urlset/master.m3u8'
+
+    item = item.clone(title='Direct', server='directo', url=url, action='play')
+    return support.server(item, itemlist=[item], Download=False, Videolibrary=False)

channels/mediasetplay.json

@@ -0,0 +1,30 @@
+{
+    "id": "mediasetplay",
+    "name": "Mediaset play infinity [free]",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "mediasetplayinfinity.png",
+    "banner": "mediasetplayinfinity.png",
+    "categories": ["movie", "tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": [
+        {
+            "id": "mpd",
+            "type": "bool",
+            "label": "Preferisci mpd",
+            "default": true,
+            "enabled": true,
+            "visible": true
+        },
+        {
+            "id": "pagination",
+            "type": "list",
+            "label": "Pagination",
+            "default": 1,
+            "enabled": true,
+            "visible": true,
+            "lvalues": ["10", "20", "30", "40", "50", "60", "70", "80", "90", "100"]
+          }
+    ]
+}

channels/mediasetplay.py

@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Mediaset Play
+# ------------------------------------------------------------
+import functools
+
+from platformcode import logger, config
+import uuid, datetime, xbmc
+
+import requests, sys
+from core import jsontools, support, httptools
+
+if sys.version_info[0] >= 3:
+    from urllib.parse import urlencode, quote
+else:
+    from urllib import urlencode, quote
+
+host = 'https://www.mediasetplay.mediaset.it'
+loginUrl = 'https://api-ott-prod-fe.mediaset.net/PROD/play/idm/anonymous/login/v2.0'
+
+clientid = 'f66e2a01-c619-4e53-8e7c-4761449dd8ee'
+
+
+loginData = {"client_id": clientid, "platform": "pc", "appName": "web//mediasetplay-web/5.1.493-plus-da8885b"}
+sessionUrl = "https://api.one.accedo.tv/session?appKey=59ad346f1de1c4000dfd09c5&uuid={uuid}&gid=default"
+
+session = requests.Session()
+session.request = functools.partial(session.request, timeout=httptools.HTTPTOOLS_DEFAULT_DOWNLOAD_TIMEOUT)
+session.headers.update({'Content-Type': 'application/json', 'User-Agent': support.httptools.get_user_agent(), 'Referer': host})
+
+entry = 'https://api.one.accedo.tv/content/entry/{id}?locale=it'
+entries = 'https://api.one.accedo.tv/content/entries?id={id}&locale=it'
+
+# login anonimo
+res = session.post(loginUrl, json=loginData, verify=False)
+Token = res.json()['response']['beToken']
+sid = res.json()['response']['sid']
+session.headers.update({'authorization': 'Bearer ' + Token})
+
+# sessione
+#sessionKey = session.get(sessionUrl.format(uuid=str(uuid.uuid4())), verify=False).json()['sessionKey']
+#session.headers.update({'x-session': sessionKey})
+
+pagination = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100][config.get_setting('pagination', 'mediasetplay')]
+
+
+@support.menu
+def mainlist(item):
+    top =  [('Dirette {bold}', ['', 'live'])]
+
+    menu = [('Film {bullet bold}', ['/cinema', 'peliculas', {'uxReference':'filmUltimiArrivi'}, 'movie']),
+            ('Film Più Visti {submenu}', ['/cinema', 'peliculas', {'uxReference':'filmPiuVisti24H'}, 'movie']),
+            ('Film Da Non Perdere {submenu}', ['/cinema', 'peliculas', {'uxReference':'filmClustering'}, 'movie']),
+            ('Fiction / Serie TV {bullet bold}', ['/fiction', 'peliculas', {'uxReference':'fictionSerieTvDelMomento'}, 'tvshow']),
+            ('Serie TV Piu Viste {submenu}', ['/fiction', 'peliculas', {'uxReference':'serieTvPiuViste24H'}, 'tvshow']),
+            ('Le Serie Soap Del Momento {submenu}', ['/cinema', 'peliculas', {'uxReference':'fictionSerieTvParamsGenre', 'params': 'genre≈Soap opera'}, 'tvshow']),
+            ('Programmi TV{ bullet bold}', ['/programmitv', 'peliculas', {'uxReference':'stagioniPrimaSerata'}, 'tvshow']),
+            ('Kids {bullet bold}', ['/kids', 'peliculas', {'uxReference':'kidsMediaset' }, 'undefined']),
+            ('Kids Boing {submenu}', ['/kids', 'peliculas', {'uxReference':'kidsBoing' }, 'undefined']),
+            ('Kids Cartoonito {submenu}', ['/kids', 'peliculas', {'uxReference':'kidsCartoonito' }, 'undefined']),
+            ('Documentari {bullet bold}', ['/documentari', 'peliculas', {'uxReference': 'documentariPiuVisti24H'}, 'undefined']),
+            ]
+
+    search = ''
+    return locals()
+
+def menu(item):
+    logger.debug()
+    itemlist = []
+    res = get_from_id(item)
+    for it in res:
+        if 'uxReference' in it:
+            itemlist.append(item.clone(title=support.typo(it['title'], 'bullet bold'),
+                            url= it['landingUrl'],
+                            args={'uxReference':it.get('uxReferenceV2', ''), 'params':it.get('uxReferenceV2Params', ''), 'feed':it.get('feedurlV2','')},
+                            action='peliculas'))
+    return itemlist
+
+
+def live(item):
+    itemlist = []
+
+    res = session.get('https://static3.mediasetplay.mediaset.it/apigw/nownext/nownext.json').json()['response']
+    allguide = res['listings']
+    stations = res['stations']
+
+    for it in stations.values():
+        logger.debug(jsontools.dump(it))
+        plot = ''
+        title = it['title']
+        url = 'https:' + it['mediasetstation$pageUrl']
+        if 'SVOD' in it['mediasetstation$channelsRights']: continue
+        thumb = it.get('thumbnails',{}).get('channel_logo-100x100',{}).get('url','')
+        if it['callSign'] in allguide:
+
+            guide = allguide[it['callSign']]
+            plot = '[B]{}[/B]\n{}'.format(guide.get('currentListing', {}).get('mediasetlisting$epgTitle', ''),guide.get('currentListing', {}).get('description', ''))
+            if 'nextListing' in guide.keys():
+                plot += '\n\nA Seguire:\n[B]{}[/B]\n{}'.format(guide.get('nextListing', {}).get('mediasetlisting$epgTitle', ''),guide.get('nextListing', {}).get('description', ''))
+            itemlist.append(item.clone(title=support.typo(title, 'bold'),
+                                       fulltitle=title, callSign=it['callSign'],
+                                    #    urls=[guide['publicUrl']],
+                                       plot=plot,
+                                       url=url,
+                                       action='findvideos',
+                                       thumbnail=thumb,
+                                       forcethumb=True))
+
+    itemlist.sort(key=lambda it: support.channels_order.get(it.fulltitle, 999))
+    support.thumb(itemlist, live=True)
+    return itemlist
+
+
+def search(item, text):
+    item.args = {'uxReference':'main', 'params':'channel≈', 'query':text}
+
+    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 []
+
+
+def peliculas(item):
+    itemlist = []
+    res = get_programs(item)
+    video_id= ''
+
+    for it in res['items']:
+        if not 'MediasetPlay_ANY' in it.get('mediasetprogram$channelsRights',['MediasetPlay_ANY']): continue
+        thumb = ''
+        fanart = ''
+        contentSerieName = ''
+        url = 'https:'+ it.get('mediasettvseason$pageUrl', it.get('mediasetprogram$videoPageUrl', it.get('mediasetprogram$pageUrl')))
+        title = it.get('mediasetprogram$brandTitle', it.get('title'))
+        title2 = it['title']
+        if title != title2:
+            title = '{} - {}'.format(title, title2)
+        plot = it.get('longDescription', it.get('description', it.get('mediasettvseason$brandDescription', '')))
+
+        if it.get('seriesTitle') or it.get('seriesTvSeasons'):
+            contentSerieName = it.get('seriesTitle', it.get('title'))
+            contentType = 'tvshow'
+            action = 'epmenu'
+        else:
+            contentType = 'movie'
+            video_id = it['guid']
+            action = 'findvideos'
+        for k, v in it['thumbnails'].items():
+            if 'image_vertical' in k and not thumb:
+                thumb = v['url'].replace('.jpg', '@3.jpg')
+            if 'image_header_poster' in k and not fanart:
+                fanart = v['url'].replace('.jpg', '@3.jpg')
+            if thumb and fanart:
+                break
+
+        itemlist.append(item.clone(title=support.typo(title, 'bold'),
+                                   fulltitle=title,
+                                   contentTitle=title,
+                                   contentSerieName=contentSerieName,
+                                   action=action,
+                                   contentType=contentType,
+                                   thumbnail=thumb,
+                                   fanart=fanart,
+                                   plot=plot,
+                                   url=url,
+                                   video_id=video_id,
+                                   seriesid = it.get('seriesTvSeasons', it.get('id','')),
+                                   disable_videolibrary = True,
+                                   forcethumb=True))
+    if res['next']:
+        item.page = res['next']
+        support.nextPage(itemlist, item)
+
+    return itemlist
+
+def epmenu(item):
+    logger.debug()
+    itemlist = []
+
+    epUrl = 'https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-subbrands-v2?byTvSeasonId={}&sort=mediasetprogram$order'
+
+    if item.seriesid:
+        if type(item.seriesid) == list:
+            res = []
+            for s in item.seriesid:
+                itemlist.append(
+                    item.clone(seriesid = s['id'],
+                               title=support.typo(s['title'], 'bold')))
+            if len(itemlist) == 1: return epmenu(itemlist[0])
+        else:
+            res = requests.get(epUrl.format(item.seriesid)).json()['entries']
+            for it in res:
+                itemlist.append(
+                    item.clone(seriesid = '',
+                               title=support.typo(it['description'], 'bold'),
+                               subbrand=it['mediasetprogram$subBrandId'],
+                               action='episodios'))
+            itemlist = sorted(itemlist, key=lambda it: it.title, reverse=True)
+            if len(itemlist) == 1: return episodios(itemlist[0])
+
+    return itemlist
+
+def episodios(item):
+    # create month list
+    months = []
+    try:
+        for month in range(21, 33): months.append(xbmc.getLocalizedString(month))
+    except:  # per i test, xbmc.getLocalizedString non è supportato
+        for month in range(21, 33): months.append('dummy')
+
+    # i programmi tv vanno ordinati per data decrescente, gli episodi delle serie per data crescente
+    order = 'desc' if '/programmi-tv/' in item.url else 'asc'
+
+    itemlist = []
+    res = requests.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-programs-v2?byCustomValue={subBrandId}{' + item.subbrand +'}&range=0-10000&sort=:publishInfo_lastPublished|' + order + ',tvSeasonEpisodeNumber').json()['entries']
+
+    for it in res:
+        thumb = ''
+        titleDate = ''
+        if 'mediasetprogram$publishInfo_lastPublished' in it:
+            date = datetime.date.fromtimestamp(it['mediasetprogram$publishInfo_lastPublished'] / 1000)
+            titleDate ='  [{} {}]'.format(date.day, months[date.month-1])
+        title = '[B]{}[/B]{}'.format(it['title'], titleDate)
+        for k, v in it['thumbnails'].items():
+            if 'image_keyframe' in k and not thumb:
+                thumb = v['url'].replace('.jpg', '@3.jpg')
+                break
+        if not thumb: thumb = item.thumbnail
+
+        itemlist.append(item.clone(title=title,
+                                   thumbnail=thumb,
+                                   forcethumb=True,
+                                   contentType='episode',
+                                   action='findvideos',
+                                   video_id=it['guid']))
+
+    return itemlist
+
+
+def findvideos(item):
+    logger.debug()
+    item.no_return=True
+    # support.dbg()
+    mpd = config.get_setting('mpd', item.channel)
+
+
+    lic_url = 'https://widevine.entitlement.theplatform.eu/wv/web/ModularDrm/getRawWidevineLicense?releasePid={pid}&account=http://access.auth.theplatform.com/data/Account/2702976343&schema=1.0&token={token}|Accept=*/*&Content-Type=&User-Agent={ua}|R{{SSM}}|'
+    url = ''
+    # support.dbg()
+    if item.urls:
+        url = ''
+        pid = ''
+        # Format = 'dash+xml' if mpd else 'x-mpegURL'
+        # for it in item.urls:
+        #     if Format in it['format']:
+        item.url = requests.head(item.urls[0], headers={'User-Agent': support.httptools.get_user_agent()}).headers['Location']
+        # pid = it['releasePids'][0]
+        # if mpd and 'widevine' in it['assetTypes']:
+        #     break
+
+        if mpd:
+            item.manifest = 'mpd'
+            item.drm = 'com.widevine.alpha'
+            item.license = lic_url.format(pid=pid, token=Token, ua=support.httptools.get_user_agent())
+
+        else:
+            item.manifest = 'hls'
+        return support.server(item, itemlist=[item], Download=False, Videolibrary=False)
+
+    elif item.video_id:
+        payload = {"contentId":item.video_id, "streamType":"VOD", "delivery":"Streaming", "createDevice":"true", "overrideAppName":"web//mediasetplay-web/5.2.4-6ad16a4"}
+        res = session.post('https://api-ott-prod-fe.mediaset.net/PROD/play/playback/check/v2.0?sid=' + sid, json=payload).json()['response']['mediaSelector']
+
+    else:
+        payload = {"channelCode":item.callSign, "streamType":"LIVE", "delivery":"Streaming", "createDevice":"true", "overrideAppName":"web//mediasetplay-web/5.2.4-6ad16a4"}
+        res = session.post('https://api-ott-prod-fe.mediaset.net/PROD/play/playback/check/v2.0?sid=' + sid, json=payload).json()['response']['mediaSelector']
+
+    url = res['url']
+    mpd = True if 'dash' in res['formats'].lower() else False
+
+    if url:
+
+        sec_data = support.match(url + '?' + urlencode(res)).data
+        item.url = support.match(sec_data, patron=r'<video src="([^"]+)').match  + '|User-Agent=' + support.httptools.get_user_agent()
+        pid = support.match(sec_data, patron=r'pid=([^|]+)').match
+
+        if mpd and pid:
+            item.manifest = 'mpd'
+            item.drm = 'com.widevine.alpha'
+            item.license = lic_url.format(pid=pid, token=Token, ua=support.httptools.get_user_agent())
+        else:
+            item.manifest = 'hls'
+
+        return support.server(item, itemlist=[item], Download=False, Videolibrary=False)
+
+
+def get_from_id(item):
+    #sessionKey = session.get(sessionUrl.format(uuid=str(uuid.uuid4())), verify=False).json()['sessionKey']
+    #session.headers.update({'x-session': sessionKey})
+    res = session.get(entry.format(id=item.args)).json()
+    if 'components' in res:
+        id = quote(",".join(res["components"]))
+        res = session.get(entries.format(id=id)).json()
+    if 'entries' in res:
+        return res['entries']
+    return {}
+
+def get_programs(item):
+    url = ''
+    pag = item.page if item.page else 1
+    ret = {}
+
+    if item.args.get('feed'):
+        pag = item.page if item.page else 1
+        url='{}&range={}-{}'.format(item.args.get('feed'), pag, pag + pagination - 1)
+        ret['next'] = pag + pagination
+        res = requests.get(url).json()
+
+    else:
+        args = {key:value for key, value in item.args.items()}
+        args['context'] = 'platform≈web'
+        args['sid'] = sid
+        args['sessionId'] = sid
+        args['hitsPerPage'] = pagination
+        args['property'] = 'search' if args.get('query') else 'play'
+        args['tenant'] = 'play-prod-v2'
+        args['page'] = pag
+        args['deviceId'] = '017ac511182d008322c989f3aac803083002507b00bd0'
+        url="https://api-ott-prod-fe.mediaset.net/PROD/play/reco/anonymous/v2.0?" + urlencode(args)
+
+        res = session.get(url).json()
+
+    if res:
+        res = res.get('response', res)
+        if 'entries' in res:
+            ret['items'] = res['entries']
+        elif 'blocks' in res:
+            items = []
+            for block in res['blocks']:
+                items += block['items']
+            ret['items'] = items
+        if not 'next' in ret:
+            next = res.get('pagination',{}).get('hasNextPage', False)
+            ret['next'] = pag + 1 if next else 0
+    return ret
+
+
+
+
+
+

channels/mediasetplay.py.old

@@ -0,0 +1,369 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Mediaset Play
+# ------------------------------------------------------------
+from platformcode import logger, config
+import uuid
+
+import requests, sys
+from core import support, jsontools
+if sys.version_info[0] >= 3: from urllib.parse import urlencode, quote
+else: from urllib import urlencode, quote
+if sys.version_info[0] >= 3: from concurrent import futures
+else: from concurrent_py2 import futures
+from collections import OrderedDict
+
+PAGINATION = 4
+
+host = config.get_channel_url()
+post_url = '?assetTypes=HD,browser,widevine,geoIT|geoNo:HD,browser,geoIT|geoNo:HD,geoIT|geoNo:SD,browser,widevine,geoIT|geoNo:SD,browser,geoIT|geoNo:SD,geoIT|geoNo&auto=true&balance=true&format=smil&formats=MPEG-DASH,MPEG4,M3U&tracking=true'
+deviceid = '61d27df7-5cbf-4419-ba06-cfd27ecd4588'
+loginUrl = 'https://api-ott-prod-fe.mediaset.net/PROD/play/idm/anonymous/login/v2.0'
+loginData = {"cid": deviceid, "platform": "pc", "appName": "web/mediasetplay-web/d667681"}
+lic_url = 'https://widevine.entitlement.theplatform.eu/wv/web/ModularDrm/getRawWidevineLicense?releasePid=%s&account=http://access.auth.theplatform.com/data/Account/2702976343&schema=1.0&token={token}|Accept=*/*&Content-Type=&User-Agent=' + support.httptools.get_user_agent() + '|R{{SSM}}|'
+entry = 'https://api.one.accedo.tv/content/entry/{id}?locale=it'
+entries = 'https://api.one.accedo.tv/content/entries?id={id}&locale=it'
+sessionUrl = "https://api.one.accedo.tv/session?appKey=59ad346f1de1c4000dfd09c5&uuid={uuid}&gid=default"
+
+current_session = requests.Session()
+current_session.headers.update({'Content-Type': 'application/json', 'User-Agent': support.httptools.get_user_agent(), 'Referer': support.config.get_channel_url()})
+
+# login anonimo
+res = current_session.post(loginUrl, json=loginData, verify=False)
+support.dbg()
+Token = res.json['response']['beToken']
+sid = res.json['response']['sid']
+current_session.headers.update({'authorization': 'Bearer' + Token})
+lic_url = lic_url.format(token=Token)
+tracecid = res.json()['response']['traceCid']
+cwid = res.json()['response']['cwId']
+
+# sessione
+res = current_session.get(sessionUrl.format(uuid=str(uuid.uuid4())), verify=False)
+current_session.headers.update({'x-session': res.json()['sessionKey']})
+
+cdict = {'CVFILM':'filmUltimiArrivi',
+         'CWFILMTOPVIEWED':'filmPiuVisti24H',
+         'CWFILMCOMEDY':'filmCommedia',
+         'CWFILMACTION':'filmAzioneThrillerAvventura',
+         'CWFILMDRAMATIC':'filmDrammatico',
+         'CWFILMSENTIMENTAL':'filmSentimentale',
+         'CWFILMCLASSIC':'filmClassici',
+         'personToContentFilm':'personToContentFilm',
+         'CWHOMEFICTIONNOWELITE':'stagioniFictionSerieTvSezione',
+         'CWFICTIONSOAP':'mostRecentSoapOpera',
+         'CWFICTIONDRAMATIC':'stagioniFictionDrammatico',
+         'CWFICTIONPOLICE':'stagioniFictionPoliziesco',
+         'CWFICTIONCOMEDY':'stagioniFictionCommedia',
+         'CWFICTIONSITCOM':'stagioniFictionSitCom',
+         'CWFICTIONSENTIMENTAL':'stagioniFictionSentimentale',
+         'CWFICTIONBIOGRAPHICAL':'stagioniFictionBiografico',
+         'CWPROGTVPRIME':'stagioniPrimaSerata',
+         'CWPROGTVDAY':'stagioniDaytime',
+         'CWPROGTVTOPVIEWED':'programmiTvClip24H',
+         'CWPROGTVTALENT':'stagioniReality',
+         'CWPROGTVVARIETY':'stagioniVarieta',
+         'CWPROGTVTALK':'stagioniTalk',
+         'CWPROGTVTG':'mostRecentTg',
+         'CWPROGTVSPORT':'mostRecentSport',
+         'CWPROGTVMAGAZINE':'stagioniCucinaLifestyle',
+         'CWDOCUMOSTRECENT':'mostRecentDocumentariFep',
+         'CWDOCUTOPVIEWED':'stagioniDocumentari',
+         'CWDOCUSPAZIO':'documentariSpazio',
+         'CWDOCUNATURANIMALI':'documentariNatura',
+         'CWDOCUSCIENZATECH':'documentariScienza',
+         'CWDOCUBIOSTORIE':'documentariBioStoria',
+         'CWDOCUINCHIESTE':'documentariInchiesta',
+         'CWFILMDOCU':'filmDocumentario',
+         'CWKIDSBOINGFORYOU':'kidsBoing',
+         'CWKIDSCARTOONITO':'kidsCartoonito',
+         'CWKIDSMEDIASETBRAND':'kidsMediaset',
+         'CWENABLERKIDS':'stagioniKids'}
+
+
+@support.menu
+def mainlist(item):
+    top =  [('Dirette {bold}', ['https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-stations?sort=ShortTitle', 'live'])]
+
+    menu = [('Fiction / Serie TV {bullet bold}', ['/fiction', 'menu', ['Tutte','all','searchStagioni', '5acfcb3c23eec6000d64a6a4'], 'tvshow']),
+            ('Programmi TV{ bullet bold}', ['/programmitv', 'menu', ['Tutti','all','searchStagioni', '5acfc8011de1c4000b6ec953'], 'tvshow']),
+            ('Documentari {bullet bold}', ['/documentari', 'menu', ['Tutti','all','', '5bfd17c423eec6001aec49f9'], 'undefined']),
+            ('Kids {bullet bold}', ['/kids', 'menu',['Tutti','all','', '5acfcb8323eec6000d64a6b3'], 'undefined'])]
+
+    search = ''
+    return locals()
+
+
+def search(item, text):
+    itemlist = []
+    logger.debug(text)
+    item.search = text
+
+    try:
+        itemlist = peliculas(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.logger.error("%s" % line)
+
+    return itemlist
+
+
+def menu(item):
+    logger.debug()
+    itemlist = []
+    if item.url:
+        json = get_from_id(item)
+        for it in json:
+            logger.debug(jsontools.dump(it))
+            if 'uxReference' in it: itemlist.append(
+                item.clone(title=support.typo(it['title'], 'bullet bold'), url= it['landingUrl'], feed = it.get('feedurlV2',''), ref=it['uxReference'], args='', action='peliculas'))
+    return itemlist
+
+
+def liveDict():
+    livedict = OrderedDict({})
+    json = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-stations?sort=ShortTitle').json()['entries']
+    for it in json:
+        urls = []
+        if it.get('tuningInstruction') and not it.get('mediasetstation$digitalOnly'):
+            guide=current_session.get('https://static3.mediasetplay.mediaset.it/apigw/nownext/' + it['callSign'] + '.json').json()['response']
+            for key in it['tuningInstruction']['urn:theplatform:tv:location:any']:
+                urls += key['publicUrls']
+            title = it['title']
+            livedict[title] = {}
+            livedict[title]['urls'] = urls
+            livedict[title]['plot'] = support.typo(guide['currentListing']['mediasetlisting$epgTitle'],'bold') + '\n' + guide['currentListing']['mediasetlisting$shortDescription'] + '\n' + guide['currentListing']['description'] + '\n\n' + support.typo('A Seguire:' + guide['nextListing']['mediasetlisting$epgTitle'], 'bold')
+    return livedict
+
+
+def live(item):
+    logger.debug()
+    itemlist = []
+    for key, value in liveDict().items():
+        itemlist.append(item.clone(title=support.typo(key, 'bold'),
+                                   fulltitle=key,
+                                   show=key,
+                                   contentTitle=key,
+                                   forcethumb=True,
+                                   urls=value['urls'],
+                                   plot=value['plot'],
+                                   action='play',
+                                   no_return=True))
+    return support.thumb(itemlist, live=True)
+
+
+def peliculas(item):
+    logger.debug()
+    itemlist = []
+    titlelist = []
+    contentType = ''
+    if item.text:
+        json = []
+        itlist = []
+        with futures.ThreadPoolExecutor() as executor:
+            for arg in ['searchMovie', 'searchStagioni', 'searchClip']:
+                item.args = ['', 'search', arg]
+                itlist += [executor.submit(get_programs, item)]
+            for res in futures.as_completed(itlist):
+                json += res.result()
+    else:
+        json = get_programs(item)
+
+    for it in json:
+        if item.search.lower() in it['title'].lower() and it['title'] not in titlelist:
+            titlelist.append(it['title'])
+            if 'media' in it:
+                action = 'findvideos'
+                contentType = 'movie'
+                urls = []
+                for key in it['media']:
+                    urls.append(key['publicUrl'])
+
+            else:
+                action = 'epmenu'
+                contentType = 'tvshow'
+                urls = it['mediasetprogram$brandId']
+            if urls:
+                title = it['mediasetprogram$brandTitle'] + ' - ' if 'mediasetprogram$brandTitle' in it and it['mediasetprogram$brandTitle'] != it['title'] else ''
+                itemlist.append(
+                    item.clone(channel=item.channel,
+                               action=action,
+                               title=support.typo(title + it['title'], 'bold'),
+                               fulltitle=it['title'],
+                               show=it['title'],
+                               contentType=contentType if contentType else item.contentType,
+                               contentTitle=it['title'] if 'movie' in [contentType, item.contentType] else '',
+                               contentSerieName=it['title'] if 'tvshow' in [contentType, item.contentType] else '',
+                               thumbnail=it['thumbnails']['image_vertical-264x396']['url'] if 'image_vertical-264x396' in it['thumbnails'] else '',
+                               fanart=it['thumbnails']['image_keyframe_poster-1280x720']['url'] if 'image_keyframe_poster-1280x720' in it['thumbnails'] else '',
+                               plot=it['longDescription'] if 'longDescription' in it else it['description'] if 'description' in it else '',
+                               urls=urls,
+                               seriesid = it.get('seriesId',''),
+                               url=it['mediasetprogram$pageUrl'],
+                               forcethumb=True,
+                               no_return=True))
+    if item.feed:
+        item.page = item.page + 100 if item.page else 101
+        support.nextPage(itemlist, item)
+    return itemlist
+
+
+def epmenu(item):
+    logger.debug()
+    itemlist = []
+
+    if item.seriesid:
+        seasons = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-tv-seasons?bySeriesId=' + item.seriesid).json()['entries']
+        for season in seasons:
+            if 'mediasettvseason$brandId' in season and 'mediasettvseason$displaySeason' in season:
+                itemlist.append(
+                    item.clone(seriesid = '',
+                               title=support.typo(season['mediasettvseason$displaySeason'], 'bold'),
+                               urls=season['mediasettvseason$brandId']))
+        itemlist = sorted(itemlist, key=lambda it: it.title, reverse=True)
+        if len(itemlist) == 1: return epmenu(itemlist[0])
+    if not itemlist:
+        entries = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-brands?byCustomValue={brandId}{' + item.urls + '}').json()['entries']
+        for entry in entries:
+            if 'mediasetprogram$subBrandId' in entry:
+                itemlist.append(
+                    item.clone(action='episodios',
+                               title=support.typo(entry['description'], 'bold'),
+                               url=entry['mediasetprogram$subBrandId'],
+                               order=entry.get('mediasetprogram$order',0)))
+        if len(itemlist) == 1: return episodios(itemlist[0])
+        itemlist = sorted(itemlist, key=lambda it: it.order)
+    return itemlist
+
+
+def episodios(item):
+    logger.debug()
+    itemlist = []
+    if not item.nextIndex: item.nextIndex = 1
+
+    url = 'https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-programs?byCustomValue={subBrandId}{'+ item.url + '}&range=' + str(item.nextIndex) + '-' + str(item.nextIndex + PAGINATION)
+    json = current_session.get(url).json()['entries']
+
+    for it in json:
+        urls = []
+        if 'media' in it:
+            for key in it['media']:
+                urls.append(key['publicUrl'])
+        if urls:
+            title = it['title']
+            itemlist.append(
+                item.clone(action='findvideos',
+                           title=support.typo(title, 'bold'),
+                           contentType='episode',
+                           thumbnail=it['thumbnails']['image_vertical-264x396']['url'] if 'image_vertical-264x396' in it['thumbnails'] else '',
+                           fanart=it['thumbnails']['image_keyframe_poster-1280x720']['url'] if 'image_keyframe_poster-1280x720' in it['thumbnails'] else '',
+                           plot=it['longDescription'] if 'longDescription' in it else it['description'],
+                           urls=urls,
+                           url=it['mediasetprogram$pageUrl'],
+                           year=it.get('year',''),
+                           ep= it.get('tvSeasonEpisodeNumber', 0) if it.get('tvSeasonEpisodeNumber', 0) else 0,
+                           forcethumb=True,
+                           no_return=True))
+
+    if len(itemlist) == 1: return findvideos(itemlist[0])
+
+    if (len(json) >= PAGINATION):
+        item.nextIndex += PAGINATION + 1
+        support.nextPage(itemlist, item)
+
+    return itemlist
+
+
+def findvideos(item):
+    logger.debug()
+    itemlist = [item.clone(server='directo', title='Mediaset Play', urls=item.urls, action='play')]
+    return support.server(item, itemlist=itemlist, Download=False)
+
+
+def play(item):
+    logger.debug()
+    for url in item.urls:
+        sec_data = support.match(url + post_url).data
+        item.url = support.match(sec_data, patron=r'<video src="([^"]+)').match
+        pid = support.match(sec_data, patron=r'pid=([^|]+)').match
+        item.manifest = 'mpd'
+
+        if pid:
+            item.drm = 'com.widevine.alpha'
+            item.license = lic_url % pid
+        break
+
+    return [item]
+
+
+def subBrand(json):
+    logger.debug()
+    subBrandId = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-brands?byCustomValue={brandId}{' + json + '}').json()['entries'][-1]['mediasetprogram$subBrandId']
+    json = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-programs?byCustomValue={subBrandId}{' + subBrandId + '}').json()['entries']
+    return json
+
+
+def get_from_id(item):
+    logger.debug()
+    json = current_session.get(entry.format(id=item.args[3])).json()
+    if 'components' in json:
+        id = quote(",".join(json["components"]))
+        json = current_session.get(entries.format(id=id)).json()
+    if 'entries' in json:
+        return json['entries']
+    return {}
+
+
+def get_programs(item, ret=[], args={}):
+    hasMore = False
+    url = ''
+    # support.dbg()
+
+    if 'search' in item.args:
+        args['uxReference'] = item.args[2]
+        args["query"] = item.text
+        args['traceCid'] = tracecid
+        args['cwId'] = cwid
+        args['page'] = 1
+        args['platform'] = 'pc'
+        args['hitsPerPage'] = 500
+        url = 'https://api-ott-prod-fe.mediaset.net/PROD/play/rec2/search/v1.0?' + urlencode(args)
+    elif item.feed:
+        pag = item.page if item.page else 1
+        url='{}&range={}-{}'.format(item.feed, pag, pag + 99)
+    elif not args:
+        if item.ref in cdict:
+            args['uxReference'] = cdict[item.ref]
+            args['platform'] = 'pc'
+        else:
+            args = {"query": "*:*"}
+            if item.args[2]:
+                args['categories'] = item.args[2]
+
+        args['cwId'] = cwid
+        args['traceCid'] = tracecid
+        args['hitsPerPage'] = 500
+        args['page'] = '0'
+        args['deviceId'] = deviceid
+        url="https://api-ott-prod-fe.mediaset.net/PROD/play/rec2/cataloguelisting/v1.0?" + urlencode(args)
+
+
+    if url:
+        json = current_session.get(url).json()
+        if 'response' in json:
+            json = json['response']
+        if 'hasMore' in json:
+            hasMore = json['hasMore']
+        if 'components' in json:
+            id = quote(",".join(json["components"]))
+            json = current_session.get(entries.format(id=id)).json()
+        if 'entries' in json:
+            ret += json['entries']
+        if hasMore:
+            args['page'] = str(int(args['page']) + 1)
+            return get_programs(item, ret, args)
+        else:
+            return ret
+    else:
+        return ret

channels/metalvideo.json

@@ -0,0 +1,11 @@
+{
+  "id": "metalvideo",
+  "name": "Metal Video",
+  "active": true,
+  "language": ["*"],
+  "thumbnail": "metalvideo.png",
+  "banner": "metalvideo.png",
+  "categories": ["music"],
+  "not_active":["include_in_global_search"],
+  "settings" :[]
+}

channels/metalvideo.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per altadefinizione01
+# ------------------------------------------------------------
+
+from core import support
+
+host = 'https://metalvideo.com'
+headers = {'X-Requested-With': 'XMLHttpRequest'}
+
+
+@support.menu
+def mainlist(item):
+    menu = [('Generi',['', 'genres']),
+           ('Ultimi Video',['/videos/latest', 'peliculas']),
+           ('Top Video',['/videos/top', 'peliculas']),
+           ('Cerca...',['','search',])]
+    return locals()
+
+
+@support.scrape
+def genres(item):
+    item.url = host
+    action = 'peliculas'
+    patronBlock = r'<div class="swiper-slide">(?P<block>.*?)<button'
+    patron = r'class="" href="(?P<url>[^"]+)[^>]+>(?P<title>[^<]+)<'
+    def itemHook(item):
+        item.thumbnail = support.thumb('music')
+        item.contentType = 'music'
+        return item
+    return locals()
+
+@support.scrape
+def peliculas(item):
+    # debug=True
+    action = 'findvideos'
+    patron= r'<a href="(?P<url>[^"]+)"[^>]+>\s*<img src="(?P<thumb>[^"]+)" alt="(?P<title>[^"]+)"[^>]*>'
+    patronNext = r'<a href="([^"]+)" data-load="[^"]+" class="[^"]+" title="Next'
+    typeContentDict = {'': 'music'}
+    def itemHook(item):
+        item.contentType = 'music'
+        item.thumbnail = item.thumbnail.replace('https:','http:')
+        return item
+    return locals()
+
+
+def findvideos(item):
+    data = support.match(item, patron=r'<source src="[^"]+').match
+    return support.server(item, Videolibrary=False, data=data)
+
+
+def search(item, text):
+    support.info(text)
+    item.url = host + '/search?keyword=' + text
+    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 []

channels/mondoserietv.json

@@ -0,0 +1,11 @@
+{
+    "id": "mondoserietv",
+    "name": "MondoSerieTV",
+    "active": false,
+    "language": ["ita"],
+    "thumbnail": "mondoserietv.png",
+    "bannermenu": "mondoserietv.png",
+    "categories": ["movie","anime","tvshow","documentary"],
+    "not_active":["include_in_newest_anime","include_in_newest_documentary"],
+    "settings": []
+}

channels/mondoserietv.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per mondoserietv
+# ----------------------------------------------------------
+
+from core import support
+
+host = support.config.get_channel_url()
+headers = {'Referer': host}
+
+
+@support.menu
+def mainlist(item):
+
+    film = ['/lista-film',
+            ('Ultimi Film Aggiunti', ['/ultimi-film-aggiunti', 'peliculas' , 'last'])]
+
+    tvshow = ['/lista-serie-tv',
+              ('HD {TV}', ['/lista-serie-tv-in-altadefinizione']),
+              ('Anni 50 60 70 80 {TV}',['/lista-serie-tv-anni-60-70-80']),
+              ('Serie Italiane',['/lista-serie-tv-italiane'])]
+
+    anime = ['/lista-cartoni-animati-e-anime']
+
+    docu = [('Documentari {bullet bold}',['/lista-documentari', 'peliculas', '', 'tvshow'])]
+
+    search = ''
+
+    return locals()
+
+
+def search(item, text):
+    support.info(text)
+    if item.contentType == 'movie' or item.extra == 'movie':
+        action = 'findvideos'
+    else:
+        action = 'episodios'
+    item.args = 'search'
+    item.url = host + "?a=b&s=" + text
+    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 []
+
+
+def newest(categoria):
+    support.info(categoria)
+    item = support.Item()
+    try:
+        if categoria == "series":
+            item.contentType= 'tvshow'
+            item.url = host + '/ultimi-episodi-aggiunti'
+            item.args = "lastep"
+        if categoria == "peliculas":
+            item.contentType= 'movie'
+            item.url = host + '/ultimi-film-aggiunti'
+            item.args = "last"
+        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 []
+
+
+@support.scrape
+def peliculas(item):
+    pagination = ''
+    anime = True
+    patronNext = r'href="([^"]+)" title="[^"]+" class="lcp_nextlink"'
+    action = 'findvideos'
+    # debug=True
+    if item.args == 'last':
+        patronBlock = r'<table>(?P<block>.*?)</table>'
+        patron = r'<tr><td><a href="(?P<url>[^"]+)">\s*[^>]+>(?P<title>.*?)(?:\s(?P<year>\d{4}))?\s*(?:Streaming|</b>)'
+    elif item.args == 'lastep':
+        patronBlock = r'<table>(?P<block>.*?)</table>'
+        patron = r'<td>\s*<a href="[^>]+>(?P<title>.*?)(?:\s(?P<year>\d{4}))?\s(?:(?P<episode>(?:\d+x\d+|\d+)))\s*(?P<title2>[^<]+)(?P<url>.*?)<tr>'
+    elif item.args == 'search':
+        patronBlock = r'<div class="peliculas">(?P<block>.*?)<div id="paginador"'
+        patron = r'class="item">\s*<a href="(?P<url>[^"]+)">\s*<div class="image">\s*<img src="(?P<thumb>[^"]+)" alt="(?P<title>.+?)(?:"| \d{4}).*?<span class="ttx">(?P<plot>[^<]+)<div class="degradado">[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(?:<span class="imdbs">(?P<rating>[^<]+))?(?:[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(?P<year>\d+))?'
+        def itemHook(item):
+            if '/film/' in item.url:
+                item.contentType = 'movie'
+                item.action = 'findvideos'
+            else:
+                item.contentType = 'tvshow'
+                item.action = 'episodios'
+            return item
+    else:
+        patronBlock = r'<div class="entry-content pagess">(?P<block>.*?)</ul>'
+        patron = r'<li\s*><a href="(?P<url>[^"]+)" title="(?P<title>.*?)(?:\s(?P<year>\d{4}))?"[^>]*>'
+    if item.contentType == 'tvshow':
+        action = 'episodios'
+        anime = True
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    anime = True
+    pagination = 50
+    patronBlock = r'<table>(?P<block>.*?)</table>'
+    patron = r'<tr><td><b>(?P<title>(?:\d+)?.*?)\s*(?:(?P<episode>(?:\d+x\d+|\d+)))\s*(?P<title2>[^<]+)(?P<data>.*?)<tr>'
+    def itemHook(item):
+        clear = support.re.sub(r'\[[^\]]+\]', '', item.title)
+        if clear.isdigit():
+            item.title = support. typo('Episodio ' + clear, 'bold')
+        return item
+    return locals()
+
+def findvideos(item):
+    if item.contentType == 'movie': return support.server(item)
+    else: return support.server(item, item.data)

channels/paramount.json

@@ -0,0 +1,12 @@
+{
+    "id": "paramount",
+    "name": "Paramount Network",
+    "active": false,
+    "language": ["ita"],
+    "thumbnail": "paramount.png",
+    "banner": "paramount.png",
+    "categories": ["movie", "tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": []
+}

channels/paramount.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Paramount Network
+# ------------------------------------------------------------
+import inspect
+from core import support, jsontools
+from platformcode import autorenumber, logger
+from collections import OrderedDict
+
+from specials import videolibrary
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+    top = [('Dirette {bold}', ['', 'live'])]
+    film = ['/film']
+    tvshow = ['/programmi']
+    return locals()
+
+@support.scrape
+def menu(item):
+    action='peliculas'
+    blacklist=['Tutti']
+    patronMenu = r'<a data-display-name="Link" href="(?P<url>[^"]+)" class="[^"]+">(?P<title>[^<]+)'
+    return locals()
+
+
+def search(item, text):
+    logger.info(text)
+
+    item.text = text
+    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 []
+
+
+def liveDict():
+    livedict = OrderedDict({})
+    urls=[]
+    matches = support.match(host, patron=r'(/diretta-tv/[^"]+)"[^>]+>([^ ]+)').matches
+    from datetime import date
+    today = date.today()
+    channels = jsontools.load(support.match(host + '/api/more/tvschedule/' + str(today.year) + str(today.month) + str(today.day)).data)['channels']
+
+    for channel in channels:
+        title = channel['label']
+        livedict[title] = {}
+        livedict[title]['id'] = channel['channelId']
+    for url, title in matches:
+        if url not in urls:
+            urls.append(url)
+            livedict[title]['url'] = host + url
+            info = jsontools.load(support.match(host +'/api/on-air?channelId=' + livedict[title]['id']).data)
+            livedict[title]['plot']= '[B]' + info['seriesTitle'] +'[/B]\n' + info['description'] if 'seriesTitle' in info else ''
+    return livedict
+
+def live(item):
+    logger.debug()
+    itemlist=[]
+    for key, value in liveDict().items():
+        itemlist.append(item.clone(title=support.typo(key,'bold'), contentTitle=key, fulltitle=key, show=key, url=value['url'], plot=value['plot'], action='findvideos', forcethumb=True, no_return=True))
+    return support.thumb(itemlist, live=True)
+
+
+def peliculas(item):
+    logger.debug()
+    def load_more(url):
+        second_url = host if url.startswith('/') else '' + url.replace('\u002F','/').replace('\\u002F','/').replace('%5C','/')
+        new_data = support.match(host + second_url).data.replace('\x01','l').replace('\x02','a')
+        return jsontools.load(new_data)['items']
+
+    itemlist = []
+    data = []
+    page_data = support.match(item.url).data
+    more = support.match(page_data, patron=r'loadingTitle":[^,]+,"url":"([^"]+)"').match
+    data = jsontools.load(support.scrapertools.decodeHtmlentities(support.match(page_data, patron=[r'"nextPageUrl":[^,]+,"items":(.*?),"customContainerClass"', r'Streaming"},"items":(.*?),"isGrid"']).match))
+
+    if data:
+        if more:
+            new_data = load_more(more)
+            data += new_data
+        for it in data:
+            try:
+                title = it['meta']['header']['title']
+            except:
+                continue
+            if item.text.lower() in title.lower():
+                itemlist.append(
+                    item.clone(title=support.typo(title,'bold'),
+                               fulltitle = title,
+                               show = title,
+                               contentTitle = title if item.contentType == 'movie' else '',
+                               contentSerieName = title if item.contentType != 'movie' else '',
+                               url = host + it['url'] if it['url'].startswith('/') else it['url'],
+                               thumbnail = it['media']['image']['url'],
+                               fanart = it['media']['image']['url'],
+                               plot = it['meta']['description'],
+                               action = 'findvideos' if item.contentType == 'movie' else 'episodios'))
+    return itemlist
+
+
+def episodios(item):
+    logger.debug()
+    reEp = r'"isEpisodes":[^,]+,"items":(.*?])'
+    def load_more(url):
+        second_url = host if url.startswith('/') else '' + url.replace('\u002F','/').replace('%5C','/')
+        new_data = support.match(host + second_url).data
+        match = support.scrapertools.decodeHtmlentities(support.match(new_data, headers=headers, patron=r'"items":([^\]]+])').match.replace('\x01','l').replace('\x02','a'))
+        return jsontools.load(match)
+
+    itemlist = []
+    page_data = support.match(item.url).data
+    seasons = support.match(page_data, patron=r'href="([^"]+)"[^>]+>Stagione\s*\d+').matches
+    more = support.match(page_data, patron=r'loadingTitle":[^,]+,"url":"([^"]+)"').match
+    data = jsontools.load(support.scrapertools.decodeHtmlentities(support.match(page_data, patron=reEp).match))
+
+    if data:
+        if more:
+            data += load_more(more)
+        if seasons:
+            for url in seasons:
+                new_data = support.match(host + url).data
+                data += jsontools.load(support.scrapertools.decodeHtmlentities(support.match(new_data, patron=reEp).match.replace('\x01','l').replace('\x02','a')))
+                match = support.match(new_data, patron=r'loadingTitle":[^,]+,"url":"([^"]+)"').match
+                if match and match != load_more:
+                    data += load_more(match)
+
+        for it in data:
+            if 'text' in it['meta']['header']['title']:
+                se = it['meta']['header']['title']['text']
+                s = support.match(se, patron=r'S\s*(?P<season>\d+)').match
+                e = support.match(se, patron=r'E\s*(?P<episode>\d+)').match
+                if not e: e = support.match(it['meta']['subHeader'], patron=r'(\d+)').match
+                title = support.typo((s + 'x' if s else 'Episodio ') + e.zfill(2) + ' - ' + it['meta']['subHeader'],'bold')
+            else:
+                s = e = '0'
+                title = support.typo(it['meta']['header']['title'],'bold')
+            itemlist.append(
+                item.clone(title=title,
+                        season=int(s) if s else '',
+                        episode=int(e),
+                        url=host + it['url'] if it['url'].startswith('/') else it['url'],
+                        thumbnail=it['media']['image']['url'],
+                        fanart=it['media']['image']['url'],
+                        plot=it['meta']['description'],
+                        contentType='episode',
+                        action='findvideos'))
+
+    itemlist.sort(key=lambda item: (item.season, item.episode))
+    if inspect.stack(0)[1][3] not in ['find_episodes']:
+        autorenumber.start(itemlist, item)
+    return support.videolibrary(itemlist, item)
+
+
+def findvideos(item):
+    logger.debug()
+    logger.debug()
+    item.manifest = 'hls'
+    mgid = support.match(item.url, patron=r'uri":"([^"]+)"').match
+    url = 'https://media.mtvnservices.com/pmt/e1/access/index.html?uri=' + mgid + '&configtype=edge&ref=' + item.url
+    ID, rootUrl = support.match(url, patron=[r'"id":"([^"]+)",',r'brightcove_mediagenRootURL":"([^"]+)"']).matches
+    item.url = jsontools.load(support.match(rootUrl.replace('&device={device}','').format(uri = ID)).data)['package']['video']['item'][0]['rendition'][0]['src']
+    return support.server(item, itemlist=[item.clone(title='Paramount', server='directo', action='play')], Download=False, Videolibrary=False)
+
+
+# def play(item):
+#     logger.debug()
+#     item.manifest = 'hls'
+#     mgid = support.match(item.url, patron=r'uri":"([^"]+)"').match
+#     url = 'https://media.mtvnservices.com/pmt/e1/access/index.html?uri=' + mgid + '&configtype=edge&ref=' + item.url
+#     ID, rootUrl = support.match(url, patron=[r'"id":"([^"]+)",',r'brightcove_mediagenRootURL":"([^"]+)"']).matches
+#     item.url = jsontools.load(support.match(rootUrl.replace('&device={device}','').format(uri = ID)).data)['package']['video']['item'][0]['rendition'][0]['src']
+
+
+#     return [item]

channels/piratestreaming.json

@@ -0,0 +1,11 @@
+{
+    "id": "piratestreaming",
+    "name": "Pirate Streaming",
+    "active": false,
+    "language": ["ita"],
+    "thumbnail": "piratestreaming.png",
+    "bannermenu": "piratestreaming.png",
+    "categories": ["anime","movie","tvshow"],
+    "settings": [],
+    "cloudflare": true
+}

channels/piratestreaming.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per piratestreaming
+# ----------------------------------------------------------
+
+
+from core import support
+from core.support import config, info
+
+host = config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
+def mainlist(item):
+
+    film = ['/category/films']
+    tvshow = ['/category/serie']
+    anime = ['/category/anime-cartoni-animati']
+    search = ''
+
+    return locals()
+
+
+def search(item, texto):
+    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 []
+
+
+def newest(categoria):
+    support.info(categoria)
+    itemlist = []
+    item = support.Item()
+    try:
+        if categoria == "peliculas":
+            item.url = host + '/category/films'
+            item.contentType = 'movies'
+            return peliculas(item)
+        if categoria == "series":
+            item.url = host + '/category/serie'
+            item.contentType = 'tvshow'
+            return peliculas(item)
+        if categoria == "anime":
+            item.url = host + '/category/anime-cartoni-animati'
+            item.contentType = 'tvshow'
+            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 []
+
+    return itemlist
+
+
+@support.scrape
+def peliculas(item):
+    patron = r'data-placement="bottom" title="(?P<title>[^"]+)" alt=[^=]+="(?P<url>[^"]+)"> <img class="[^"]+" title="[^"]+(?P<type>film|serie)[^"]+" alt="[^"]+" src="(?P<thumb>[^"]+)"'
+    patronNext = r'<a\s*class="nextpostslink" rel="next" href="([^"]+)">Avanti'
+
+    typeActionDict = {'findvideos': ['film'], 'episodios': ['serie']}
+    typeContentDict = {'movie': ['film'], 'tvshow': ['serie']}
+    # debug = True
+    return locals()
+
+
+@support.scrape
+def episodios(item):
+    if item.data: data = item.data
+    # debug= True
+    title = item.fulltitle
+    patron = r'link-episode">(?:\s*<strong>)?\s*(?P<episode>\d+.\d+(?:.\d+)?)(?:\s*\((?P<lang>[?P<lang>A-Za-z-]+)[^>]+>)?(?:\s*(?P<title>[^-<]+))[^>]+</span>\s*(?P<url>.*?)</div>'
+    def itemHook(item):
+        if 'Episodio' in item.title:
+            item.title = support.re.sub(r'Episodio [0-9.-]+', title, item.title)
+        return item
+    return locals()
+
+
+def findvideos(item):
+    if item.contentType == 'episode':
+        data = item.url
+    else:
+        data = support.match(item).data
+        if 'link-episode' in data:
+            item.data = data
+            return episodios(item)
+    return support.server(item, data=data)

channels/plutotv.json

@@ -0,0 +1,12 @@
+{
+    "id": "plutotv",
+    "name": "Pluto TV",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "plutotv.png",
+    "banner": "plutotv.png",
+    "categories": ["movie", "tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": []
+}

channels/plutotv.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per Pluto TV
+# ------------------------------------------------------------
+
+import uuid, datetime
+from platformcode import logger, config
+from core.item import Item
+from core import jsontools, support, httptools
+
+host = support.config.get_channel_url()
+
+api = 'https://api.pluto.tv'
+UUID = 'sid={}&deviceId={}'.format(uuid.uuid1().hex, uuid.uuid4().hex)
+vod_url = '{}/v3/vod/categories?includeItems=true&deviceType=web&'.format(api, UUID)
+
+@support.menu
+def mainlist(item):
+    top =  [('Dirette {bold}', ['/it/live-tv/', 'live'])]
+
+    menu = [('Categorie', ['', 'category'])]
+
+    search = ''
+
+    return locals()
+
+@support.menu
+def category(item):
+    menu = sorted([(it['name'], ['/it/on-demand', 'peliculas', it['items']]) for it in httptools.downloadpage(vod_url).json['categories'][1:]])
+    return locals()
+
+def live(item):
+    logger.debug()
+
+    now = datetime.datetime.now()
+    start = (now.strftime('%Y-%m-%dT%H:00:00Z'))
+    stop  = (now + datetime.timedelta(hours=4)).strftime('%Y-%m-%dT%H:00:00Z')
+
+
+    live_url = '{}/v2/channels.json?{}'.format(api, UUID)
+    guide_url = '{}/v2/channels?start={}&stop={}&{}'.format(api, start, stop, UUID)
+
+    guide = {g['number']:[g['timelines'][0]['title'], g['timelines'][1]['title']] for g in httptools.downloadpage(guide_url).json}
+
+    itemlist = []
+
+    for it in httptools.downloadpage(live_url).json:
+        itemlist.append(item.clone(title= '[B]{}[/B] | {}'.format(it['name'], guide[it['number']][0]),
+                                   number=it['number'],
+                                   contentTitle=it['name'],
+                                   action='findvideos',
+                                   thumbnail=it['solidLogoPNG']['path'],
+                                   fanart=it['featuredImage']['path'],
+                                   plot='{}\n\n[B]A seguire:[/B]\n{}'.format(it['summary'], guide[it['number']][1]),
+                                   videourl= it['stitched']['urls'][0]['url'].split('?')[0],
+                                   forcethumb=True))
+    itemlist.sort(key=lambda it: it.number)
+    return itemlist
+
+
+def search(item, text):
+    logger.debug('Search', text)
+    try:
+        item.search = text.lower()
+        item.args = []
+        for it in httptools.downloadpage(vod_url).json['categories'][1:]:
+            item.args.extend(it['items'])
+        return peliculas(item)
+
+    except:
+        import sys
+        for line in sys.exc_info():
+            support.logger.error("%s" % line)
+            return []
+
+
+def peliculas(item):
+    logger.debug()
+    itemlist = []
+    recordlist = []
+
+    for i, it in enumerate(item.args):
+        if item.search in it['name'].lower():
+            itm = Item(channel=item.channel,
+                       url=item.url,
+                       title=it['name'],
+                       contentTitle=it['name'],
+                       contentSerieName= it['name'] if it['type'] == 'series' else '',
+                       plot=it['description'],
+                       contentType='tvshow' if it['type'] == 'series' else 'movie',
+                       action='episodios' if it['type'] == 'series' else 'findvideos',
+                       thumbnail= it['covers'][0]['url'],
+                       fanart= it['covers'][2]['url'] if len(it['covers']) > 2 else '',
+                       id= it['_id'],
+                       videourl= it.get('stitched', {}).get('urls', [{}])[0].get('url','').split('?')[0])
+
+            if i < 20 or item.search:
+                itemlist.append(itm)
+            else:
+                recordlist.append(it)
+
+    support.tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    if recordlist and not item.search:
+        itemlist.append(item.clone(title=support.typo(support.config.get_localized_string(30992), 'color kod bold'), thumbnail=support.thumb(), args=recordlist))
+    return itemlist
+
+
+def episodios(item):
+    logger.debug()
+    itemlist = []
+    seasons = httptools.downloadpage('{}/v3/vod/series/{}/seasons?includeItems=true&deviceType=web&{}'.format(api, item.id, UUID)).json['seasons']
+    for season in seasons:
+        for episode in season['episodes']:
+            itemlist.append(item.clone(title='{}x{:02d} - {}'.format(episode['season'], episode['number'], episode['name']),
+                                       contrentTitle=episode['name'],
+                                       contentSeason=episode['season'],
+                                       contentEpisodeNumber=episode['number'],
+                                       plot=episode['description'],
+                                       thumbnail=episode['covers'][1]['url'],
+                                       videourl=episode['stitched']['urls'][0]['url'].split('?')[0],
+                                       action='findvideos'))
+
+    if config.get_setting('episode_info'):
+        support.tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
+    support.videolibrary(itemlist,item)
+    return itemlist
+
+
+def findvideos(item):
+    item.server = 'directo'
+    item.manifest='hls'
+    params = '{}?deviceDNT=0&deviceVersion=unknow&appVersion=unknow&deviceType=web&deviceMake=firefox&deviceModel=firefox&appName=web&{}'
+    item.url = params.format(item.videourl, UUID)
+    return support.server(item, itemlist=[item],  Download=False, Videolibrary=False)

channels/raiplay.json

@@ -0,0 +1,13 @@
+{
+    "id": "raiplay",
+    "name": "Rai Play",
+    "active": true,
+    "language": ["ita"],
+    "thumbnail": "raiplay.png",
+    "banner": "raiplay.png",
+    "categories": ["movie", "tvshow", "documentary", "live"],
+    "not_active": ["include_in_newest"],
+    "default_off": ["include_in_global_search"],
+    "settings": [],
+    "cloudflare": true
+}