update updater config

Reviewed-on: #1

.directory

@@ -1,6 +0,0 @@
-[Dolphin]
-Timestamp=2019,4,23,18,58,8
-Version=4
-
-[Settings]
-HiddenFilesShown=true

.gitea/workflows/updateDomains.yaml

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

.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

@@ -3,4 +3,11 @@
 .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,24 +1,13 @@
 # Kodi On Demand
 ### Un fork italiano di [Alfa](https://github.com/alfa-addon)
-Ognuno è libero (anzi, invitato!) a collaborare, per farlo è possibile utilizzare i pull request.
 
-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: 
+Installazione: https://kodiondemand.github.io/#download
+
+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 preservarnee lo storico)
+- 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)
 
-### Come contribuire?
-- Fai un Fork del repository.
-- Effettua tutte le modifiche e fai un push nel tuo repository remoto.
-- Testa tutte le funzioni principali (videoteca, autoplay, scraper web) o eventuali aggiunte extra.
-- Apri una pull request.
+### 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)
 
-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.
-
-Se parte del codice di un tuo addon è stato incluso in questo progetto e ne desideri l'eliminazione, crea una issue portando le prove di essere veramente uno dei dev e lo elimineremo.
-
-### Qualcosa non funziona?
-Sentiti libero di segnalarlo al team [qui](https://github.com/kodiondemand/addon/issues)

_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-midnight

addon.xml

@@ -1,26 +1,34 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<addon id="plugin.video.kod" name="Kodi on Demand" version="0.3.1" provider-name="KOD Team">
+<addon id="plugin.video.kod" name="Kodi on Demand" version="1.7.7" provider-name="KoD Team">
   <requires>
-    <import addon="xbmc.python" version="2.1.0"/>
-    <import addon="script.module.libtorrent" optional="true"/>
-    <import addon="metadata.themoviedb.org"/>
-    <import addon="metadata.tvdb.com"/>
-    <import addon="script.module.web-pdb" />
+    <!-- <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>logo.png</icon>
-      <fanart>fanart.jpg</fanart>
-      <screenshot>resources/media/themes/ss/1.png</screenshot>
-      <screenshot>resources/media/themes/ss/2.png</screenshot>
-      <screenshot>resources/media/themes/ss/3.png</screenshot>
+      <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>Benvenuto su KOD!</news>
+      <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>
@@ -30,6 +38,6 @@
     <forum>https://t.me/kodiondemand</forum>
     <source>https://github.com/kodiondemand/addon</source>
   </extension>
-  <extension point="xbmc.service" library="videolibrary_service.py" start="login|startup">
+  <extension point="xbmc.service" library="service.py" start="login|startup">
   </extension>
 </addon>

channels.json

@@ -1,63 +1,44 @@
 {
-    "altadefinizione01_club": "https://www.altadefinizione01.cc",
-    "altadefinizione01_link": "http://altadefinizione01.link",
-    "altadefinizione01": "https://altadefinizione01.to",
-    "altadefinizioneclick": "https://altadefinizione.cloud",
-    "altadefinizionehd": "https://altadefinizione.doctor",
-    "animeforge": "https://ww1.animeforce.org",
-    "animeleggendari": "https://animepertutti.com",
-    "animestream": "https://www.animeworld.it",
-    "animespace": "https://animespace.tv",
-    "animesubita": "http://www.animesubita.org",
-    "animetubeita": "http://www.animetubeita.com",
-    "animevision": "https://www.animevision.it",
-    "animeworld": "https://www.animeworld.it",
-    "asiansubita": "http://asiansubita.altervista.org",
-    "casacinema": "https://www.casacinema.site",
-    "casacinemainfo": "https://www.casacinema.info",
-    "cb01anime": "http://www.cineblog01.ink",
-    "cinemalibero": "https://cinemalibero.icu",
-    "cinemastreaming": "https://cinemastreaming.icu",
-    "documentaristreamingda": "https://documentari-streaming-da.com",
-    "dreamsub": "https://www.dreamsub.stream",
-    "eurostreaming": "https://eurostreaming.gratis",
-    "eurostreaming_video": "https://www.eurostreaming.best",
-    "fastsubita": "http://fastsubita.com",
-    "ffilms":"https://ffilms.org",
-    "filmigratis": "https://filmigratis.net",
-    "filmgratis": "https://www.filmaltadefinizione.net",
-    "filmontv": "https://www.comingsoon.it",
-    "filmpertutti": "https://www.filmpertutti.tube",
-    "filmsenzalimiti": "https://filmsenzalimiti.best",
-    "filmsenzalimiticc": "https://www.filmsenzalimiti.host",
-    "filmsenzalimiti_blue": "https://filmsenzalimiti.best",
-    "filmsenzalimiti_info": "https://www.filmsenzalimiti.host",
-    "filmstreaming01": "https://filmstreaming01.com",
-    "filmstreamingita": "http://filmstreamingita.live",
-    "guarda_serie": "https://guardaserie.site",
-    "guardafilm": "http://www.guardafilm.top",
-    "guardarefilm": "https://www.guardarefilm.video",
-    "guardaseriecc": "https://guardaserie.site",
-    "guardaserieclick": "https://www.guardaserie.media",
-    "guardaserie_stream": "https://guardaserie.co",
-    "guardaserieonline": "http://www.guardaserie.media",
-    "guardogratis": "http://guardogratis.io",
-    "ilgeniodellostreaming": "https://ilgeniodellostreaming.pw",
-    "italiafilm": "https://www.italia-film.pw",
-    "italiafilmhd": "https://italiafilm.info",
-    "italiaserie": "https://italiaserie.org",
-    "itastreaming": "https://itastreaming.film",
-    "majintoon": "https://toonitalia.org",
-    "mondolunatico": "http://mondolunatico.org",
-    "mondolunatico2": "http://mondolunatico.org/stream/",
-    "mondoserietv": "https://mondoserietv.com",
-    "piratestreaming": "https://www.piratestreaming.watch",
-    "seriehd": "https://www.seriehd.info",
-    "serietvonline": "https://serietvonline.xyz",
-    "serietvsubita": "http://serietvsubita.xyz",
-    "serietvu": "https://www.serietvu.club",
-    "streamingaltadefinizione": "https://www.streamingaltadefinizione.space",
-    "streamking": "http://streamking.cc",
-    "tantifilm": "https://www.tantifilm.plus",
-    "toonitalia": "https://toonitalia.org"
-}
+    "direct": {
+        "altadefinizione01": "https://altadefinizione01.pet",
+        "animealtadefinizione": "http://ww38.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://cb01new.one",
+        "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.lifestyle",
+        "eurostreaming_actor": "https://eurostreaming.my",
+        "filmstreaming": "https://film-streaming-ita.cam",
+        "guardaseriecam": "https://guardaserie.kitchen",
+        "hd4me": "https://hd4me.net",
+        "ilcorsaronero": "https://ilcorsaronero.link",
+        "ilgeniodellostreaming_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.ooo",
+        "streamingita": "https://streamingita.click",
+        "tantifilm": "https://tantifilm.name",
+        "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/LIKUOO.json

@@ -1,16 +0,0 @@
-{
-  "id": "LIKUOO",
-  "name": "LIKUOO",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "https://likuoo.video/files_static/images/logo.jpg",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-  
-  ]
-}
-

channels/LIKUOO.py

@@ -1,95 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core import servertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'http://www.likuoo.video'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Ultimos" , action="lista", url=host))
-    itemlist.append( Item(channel=item.channel, title="Pornstar" , action="categorias", url=host + "/pornstars/"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/all-channels/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/search/?s=%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron  = '<div class="item_p">.*?<a href="([^"]+)" title="([^"]+)"><img src="([^"]+)"'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail in matches:
-        scrapedplot = ""
-        scrapedthumbnail = "https:" + scrapedthumbnail
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl)
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    next_page = scrapertools.find_single_match(data,'...<a href="([^"]+)" class="next">&#187;</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="categorias", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<div class="item">.*?'
-    patron += '<a href="([^"]+)" title="(.*?)">.*?'
-    patron += 'src="(.*?)".*?'
-    patron += '<div class="runtime">(.*?)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,scrapedtime in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        scrapedtime = scrapedtime.replace("m", ":").replace("s", " ")
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " +scrapedtitle
-        contentTitle = title
-        thumbnail = "https:" + scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail,
-                              fanart=thumbnail, plot=plot, contentTitle = contentTitle))
-    next_page = scrapertools.find_single_match(data,'...<a href="([^"]+)" class="next">&#187;</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    data = httptools.downloadpage(item.url).data
-    itemlist = servertools.find_video_items(data=data)
-    for videoitem in itemlist:
-        videoitem.title = item.fulltitle
-        videoitem.fulltitle = item.fulltitle
-        videoitem.thumbnail = item.thumbnail
-        videochannel=item.channel
-    return itemlist
-

channels/TXXX.json

@@ -1,16 +0,0 @@
-{
-  "id": "TXXX",
-  "name": "TXXX",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://www.txxx.com/images/desktop-logo.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-
-  ]
-}
-

channels/TXXX.py

@@ -1,151 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urllib
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'http://www.txxx.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Ultimas" , action="lista", url=host + "/latest-updates/"))
-    itemlist.append( Item(channel=item.channel, title="Mejor valoradas" , action="lista", url=host + "/top-rated/"))
-    itemlist.append( Item(channel=item.channel, title="Mas popular" , action="lista", url=host + "/most-popular/"))
-    itemlist.append( Item(channel=item.channel, title="Canal" , action="catalogo", url=host + "/channels-list/most-popular/"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/categories/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/search/s=%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def catalogo(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<div class="channel-thumb">.*?'
-    patron += '<a href="([^"]+)" title="([^"]+)".*?'
-    patron += '<img src="([^"]+)".*?'
-    patron += '<span>(.*?)</span>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,num in matches:
-        scrapedplot = ""
-        scrapedurl = host + scrapedurl
-        title = scrapedtitle + "[COLOR yellow]  " + num + "[/COLOR]"
-        itemlist.append( Item(channel=item.channel, action="lista", title=title , url=scrapedurl , 
-                        thumbnail=scrapedthumbnail , plot=scrapedplot) )
-    next_page = scrapertools.find_single_match(data,'<a class=" btn btn--size--l btn--next" href="([^"]+)" title="Next Page"')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append( Item(channel=item.channel , action="catalogo" , title="Página Siguiente >>" , 
-                        text_color="blue", url=next_page) )
-    return itemlist
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron = '<a class="categories-list__link" href="([^"]+)">.*?'
-    patron += '<span class="categories-list__name cat-icon" data-title="([^"]+)">.*?'
-    patron += '<span class="categories-list__badge">(.*?)</span>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,num in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        scrapedthumbnail = ""
-        scrapedplot = ""
-        title = scrapedtitle + "[COLOR yellow]  " + num + "[/COLOR]"
-        itemlist.append( Item(channel=item.channel, action="lista", title=title , url=url , 
-                        thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = 'data-video-id="\d+">.*?<a href="([^"]+)".*?'
-    patron += '<img src="([^"]+)" alt="([^"]+)".*?'
-    patron += '</div>(.*?)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle,scrapedtime in matches:
-        contentTitle = scrapedtitle
-        scrapedhd = scrapertools.find_single_match(scrapedtime, '<span class="thumb__hd">(.*?)</span>')
-        duration = scrapertools.find_single_match(scrapedtime, '<span class="thumb__duration">(.*?)</span>')
-        if scrapedhd != '':
-            title = "[COLOR yellow]" +duration+ "[/COLOR] " + "[COLOR red]" +scrapedhd+ "[/COLOR]  "+scrapedtitle
-        else:
-            title = "[COLOR yellow]" + duration + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play" , title=title , url=scrapedurl, thumbnail=thumbnail, 
-                        plot=plot, contentTitle=title) )
-    next_page = scrapertools.find_single_match(data,'<a class=" btn btn--size--l btn--next.*?" href="([^"]+)" title="Next Page"')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    video_url = scrapertools.find_single_match(data, 'var video_url = "([^"]*)"')
-    video_url += scrapertools.find_single_match(data, 'video_url \+= "([^"]*)"')
-    partes = video_url.split('||')
-    video_url = decode_url(partes[0])
-    video_url = re.sub('/get_file/\d+/[0-9a-z]{32}/', partes[1], video_url)
-    video_url += '&' if '?' in video_url else '?'
-    video_url += 'lip=' + partes[2] + '&lt=' + partes[3]
-    itemlist.append(item.clone(action="play", title=item.title, url=video_url))
-    return itemlist
-
-
-def decode_url(txt):
-    _0x52f6x15 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,~'
-    reto = ''; n = 0
-    # En las dos siguientes líneas, ABCEM ocupan 2 bytes cada letra! El replace lo deja en 1 byte. !!!!: АВСЕМ (10 bytes) ABCEM (5 bytes)
-    txt = re.sub('[^АВСЕМA-Za-z0-9\.\,\~]', '', txt)
-    txt = txt.replace('А', 'A').replace('В', 'B').replace('С', 'C').replace('Е', 'E').replace('М', 'M')
-
-    while n < len(txt):
-        a = _0x52f6x15.index(txt[n])
-        n += 1
-        b = _0x52f6x15.index(txt[n])
-        n += 1
-        c = _0x52f6x15.index(txt[n])
-        n += 1
-        d = _0x52f6x15.index(txt[n])
-        n += 1
-
-        a = a << 2 | b >> 4
-        b = (b & 15) << 4 | c >> 2
-        e = (c & 3) << 6 | d
-        reto += chr(a)
-        if c != 64: reto += chr(b)
-        if d != 64: reto += chr(e)
-
-    return urllib.unquote(reto)
-

channels/absoluporn.json

@@ -1,15 +0,0 @@
-{
-  "id": "absoluporn",
-  "name": "absoluporn",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://www.absoluporn.es/image/deco/logo.gif",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-  ]
-}
-

channels/absoluporn.py

@@ -1,96 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'http://www.absoluporn.es'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-
-    itemlist.append( Item(channel=item.channel, title="Nuevos" , action="lista", url=host + "/wall-date-1.html"))
-    itemlist.append( Item(channel=item.channel, title="Mas valorados" , action="lista", url=host + "/wall-note-1.html"))
-    itemlist.append( Item(channel=item.channel, title="Mas vistos" , action="lista", url=host + "/wall-main-1.html"))
-    itemlist.append( Item(channel=item.channel, title="Mas largos" , action="lista", url=host + "/wall-time-1.html"))
-
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/search-%s-1.html" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '&nbsp;<a href="([^"]+)" class="link1">([^"]+)</a>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle in matches:
-        scrapedplot = ""
-        scrapedthumbnail = ""
-        scrapedurl = scrapedurl.replace(".html", "_date.html")
-        scrapedurl = host +"/" + scrapedurl
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              thumbnail=scrapedthumbnail , plot=scrapedplot) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>|<br/>", "", data)
-    patron = '<div class="thumb-main-titre"><a href="([^"]+)".*?'
-    patron += 'title="([^"]+)".*?'
-    patron += 'src="([^"]+)".*?'
-    patron += '<div class="time">(.*?)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,scrapedtime in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail, plot=plot,
-                              fanart=thumbnail, contentTitle = scrapedtitle))
-    next_page = scrapertools.find_single_match(data, '<span class="text16">\d+</span> <a href="..([^"]+)"')
-    if next_page:
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append( Item(channel=item.channel, action="lista", title="Página Siguiente >>", text_color="blue", 
-                              url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = 'servervideo = \'([^\']+)\'.*?'
-    patron += 'path = \'([^\']+)\'.*?'
-    patron += 'filee = \'([^\']+)\'.*?'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for servervideo,path,filee  in matches:
-        scrapedurl = servervideo + path + "56ea912c4df934c216c352fa8d623af3" + filee
-        itemlist.append(Item(channel=item.channel, action="play", title=item.title, fulltitle=item.fulltitle, url=scrapedurl,
-                            thumbnail=item.thumbnail, plot=item.plot, show=item.title, server="directo", folder=False))
-    return itemlist
-

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

@@ -1,14 +0,0 @@
-{
-  "id": "alsoporn",
-  "name": "alsoporn",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://alsoporn.com/images/alsoporn.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-  ]
-}

channels/alsoporn.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'http://www.alsoporn.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    # itemlist.append( Item(channel=item.channel, title="Nuevos" , action="lista", url=host + "/en/g/All/new/1"))
-    itemlist.append( Item(channel=item.channel, title="Top" , action="lista", url=host + "/g/All/top/1"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/search/=%s/" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<a href="([^"]+)">.*?'
-    patron += '<img src="([^"]+)" alt="([^"]+)" />'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle in matches:
-        scrapedplot = ""
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl)
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl, 
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return sorted(itemlist, key=lambda i: i.title)
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<div class="alsoporn_prev">.*?'
-    patron += '<a href="([^"]+)">.*?'
-    patron += '<img src="([^"]+)" alt="([^"]+)">.*?'
-    patron += '<span>([^"]+)</span>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle,scrapedtime in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail,
-                              fanart=thumbnail, plot=plot, contentTitle = scrapedtitle))
-
-    next_page = scrapertools.find_single_match(data,'<li><a href="([^"]+)" target="_self"><span class="alsoporn_page">NEXT</span></a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    scrapedurl = scrapertools.find_single_match(data,'<iframe frameborder=0 scrolling="no"  src=\'([^\']+)\'')
-    data = httptools.downloadpage(item.url).data
-    scrapedurl1 = scrapertools.find_single_match(data,'<iframe src="(.*?)"')
-    scrapedurl1 = scrapedurl1.replace("//www.playercdn.com/ec/i2.php?", "https://www.trinitytube.xyz/ec/i2.php?")
-    data = httptools.downloadpage(item.url).data
-    scrapedurl2 = scrapertools.find_single_match(data,'<source src="(.*?)"')
-    itemlist.append(item.clone(action="play", title=item.title, fulltitle = item.title, url=scrapedurl2))
-    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

@@ -1,62 +1,10 @@
 {
     "id": "altadefinizione01",
     "name": "Altadefinizione01",
-    "language": ["ita"],
+    "language": ["ita", "sub-ita"],
     "active": true,
-    "adult": false,
-    "thumbnail": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/altadefinizione01.png",
-    "banner": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/altadefinizione01.png",
-    "categories": ["movie"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi in Ricerca Globale",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "checklinks",
-            "type": "bool",
-            "label": "Verifica se i link esistono",
-            "default": false,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "checklinks_number",
-            "type": "list",
-            "label": "Numero di link da verificare",
-            "default": 1,
-            "enabled": true,
-            "visible": "eq(-1,true)",
-            "lvalues": [ "5", "10", "15", "20" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
+    "thumbnail": "altadefinizione01.png",
+    "banner": "altadefinizione01.png",
+    "categories": ["movie", "vos"],
+    "settings": []
 }

channels/altadefinizione01.py

@@ -2,72 +2,137 @@
 # ------------------------------------------------------------
 # Canale per altadefinizione01
 # ------------------------------------------------------------
-
-from core import servertools, httptools, tmdb, scrapertoolsV2, support
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
-
-#URL che reindirizza sempre al dominio corrente
-#host = "https://altadefinizione01.to"
-
-__channel__ = "altadefinizione01"
-host = config.get_channel_url(__channel__)
-
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['openload', 'streamango', 'rapidvideo', 'streamcherry', 'megadrive']
-list_quality = ['default']
-
-checklinks = config.get_setting('checklinks', 'altadefinizione01')
-checklinks_number = config.get_setting('checklinks_number', 'altadefinizione01')
-
-headers = [['Referer', host]]
-blacklist_categorie = ['Altadefinizione01', 'Altadefinizione.to']
-
-
-def mainlist(item):
-    support.log()
-
-    itemlist =[]
-
-    support.menu(itemlist, 'Al Cinema','peliculas',host+'/cinema/')
-    support.menu(itemlist, 'Ultimi Film Inseriti','peliculas',host)
-    support.menu(itemlist, 'Film Sub-ITA','peliculas',host+'/sub-ita/')
-    support.menu(itemlist, 'Film Ordine Alfabetico ','AZlist',host+'/catalog/')
-    support.menu(itemlist, 'Categorie Film','categories',host)
-    support.menu(itemlist, 'Cerca...','search')
+"""
     
-    autoplay.init(item.channel, list_servers, list_quality)
-    autoplay.show_option(item.channel, itemlist)
+    Eccezioni note che non superano il test del canale:
 
-    return itemlist
+    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 categories(item):
-    support.log(item)
-    itemlist = support.scrape(item,'<li><a href="([^"]+)">(.*?)</a></li>',['url','title'],headers,'Altadefinizione01',patron_block='<ul class="kategori_list">(.*?)</ul>',action='peliculas')
-    return support.thumb(itemlist)
+# def findhost(url):
+#     data = httptools.downloadpage(url).data
+#     host = scrapertools.find_single_match(data, '<div class="elementor-button-wrapper"> <a href="([^"]+)"')
+#     return host
 
-def AZlist(item):
-    support.log()
-    return support.scrape(item,r'<a title="([^"]+)" href="([^"]+)"',['title','url'],headers,patron_block=r'<div class="movies-letter">(.*?)<\/div>',action='peliculas_list')
 
+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):
-    # import web_pdb; web_pdb.set_trace()
-    support.log(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 
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
@@ -77,77 +142,16 @@ def newest(categoria):
     return itemlist
 
 
-def search(item, texto):
-    support.log(texto)
-    item.url = "%s/index.php?do=search&story=%s&subaction=search" % (
-        host, texto)
-    try:
-        if item.extra == "movie":
-            return subIta(item)
-        if item.extra == "tvshow":
-            return peliculas_tv(item)
-    # Continua la ricerca in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def peliculas(item):
-    support.log()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-    patron = r'<div class="cover_kapsul ml-mask".*?<a href="(.*?)">(.*?)<\/a>.*?<img .*?src="(.*?)".*?<div class="trdublaj">(.*?)<\/div>.(<div class="sub_ita">(.*?)<\/div>|())'
-    matches = scrapertoolsV2.find_multiple_matches(data, patron)
-    
-    for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedquality, subDiv, subText, empty in matches:
-        info = scrapertoolsV2.find_multiple_matches(data, r'<span class="ml-label">([0-9]+)+<\/span>.*?<span class="ml-label">(.*?)<\/span>.*?<p class="ml-cat".*?<p>(.*?)<\/p>.*?<a href="(.*?)" class="ml-watch">')
-        infoLabels = {}
-        for infoLabels['year'], duration, scrapedplot, checkUrl in info:
-            if checkUrl == scrapedurl:
-                break
-
-        infoLabels['duration'] = int(duration.replace(' min', '')) * 60  # calcolo la durata in secondi
-        scrapedthumbnail = host + scrapedthumbnail
-        scrapedtitle = scrapertoolsV2.decodeHtmlentities(scrapedtitle)
-        fulltitle = scrapedtitle
-        if subDiv:
-            fulltitle += support.typo(subText + ' _ () color limegreen')
-        fulltitle += support.typo(scrapedquality.strip()+ ' _ [] color kod')
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType=item.contenType,
-                 contentTitle=scrapedtitle,
-                 contentQuality=scrapedquality.strip(),
-                 plot=scrapedplot,
-                 title=fulltitle,
-                 fulltitle=scrapedtitle,
-                 show=scrapedtitle,
-                 url=scrapedurl,
-                 infoLabels=infoLabels,
-                 thumbnail=scrapedthumbnail))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    support.nextPage(itemlist,item,data,'<span>[^<]+</span>[^<]+<a href="(.*?)">')
-
-    return itemlist
-
-def peliculas_list(item):
-    support.log()
-    item.fulltitle = ''
-    block = r'<tbody>(.*)<\/tbody>'
-    patron = r'<a href="([^"]+)" title="([^"]+)".*?> <img.*?src="([^"]+)".*?<td class="mlnh-3">([0-9]{4}).*?mlnh-4">([A-Z]+)'
-    return support.scrape(item,patron, ['url', 'title', 'thumb', 'year', 'quality'], patron_block=block)
-
-
-
 def findvideos(item):
-    support.log()
+    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)
     
-    itemlist = support.server(item, headers=headers)
-
-    return itemlist
+    # TODO: verificare se si puo' reinsierire il trailer youtube
+    #itemlist = [item.clone(action="play", url=srv[0], quality=srv[1]) for srv in support.match(item, patron='<a href="#" data-link="([^"]+).*?<span class="d">([^<]+)').matches]
+    #itemlist = support.server(item, itemlist=itemlist, headers=headers)   
+        
+    #return itemlist

channels/altadefinizione01_club.json

@@ -1,76 +0,0 @@
-{
-  "id": "altadefinizione01_club",
-  "name": "Altadefinizione01 C",
-  "active": true,
-  "adult": false,
-  "language": ["ita"],
-  "fanart": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
-  "thumbnail": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
-  "banner": "https://www.altadefinizione01.vision/templates/Darktemplate/images/logo.png",
-  "categories": [
-    "movie"
-  ],
-  "settings": [
-    {
-      "id": "modo_grafico",
-      "type": "bool",
-      "label": "Cerca informazioni extra",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_film",
-      "type": "bool",
-      "label": "Includi in Novità",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-     "id": "include_in_newest_italiano",
-      "type": "bool",
-      "label": "Includi in Novità - Italiano",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },  
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Includi ricerca globale",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "checklinks",
-      "type": "bool",
-      "label": "Verifica se i link esistono",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "checklinks_number",
-      "type": "list",
-      "label": "Numero de link da verificare",
-      "default": 1,
-      "enabled": true,
-      "visible": "eq(-1,true)",
-      "lvalues": [ "5", "10", "15", "20" ]
-    },
-    {
-      "id": "filter_languages",
-      "type": "list",
-      "label": "Mostra link in lingua...",
-      "default": 0,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "Non filtrare",
-        "IT"
-      ]
-    }
-	  ]
-}

channels/altadefinizione01_club.py

@@ -1,269 +0,0 @@
-# -*- coding: utf-8 -*-
-# -*- Channel Altadefinizione01C Film -*-
-# -*- Riscritto per KOD -*-
-# -*- By Greko -*-
-# -*- last change: 04/05/2019
-
-
-from channelselector import get_thumb
-from core import httptools, channeltools, scrapertools, servertools, tmdb, support
-from core.item import Item
-from platformcode import config, logger
-from specials import autoplay, filtertools
-
-__channel__ = "altadefinizione01_club"
-host = config.get_channel_url(__channel__)
-
-# ======== Funzionalità =============================
-
-checklinks = config.get_setting('checklinks', __channel__)
-checklinks_number = config.get_setting('checklinks_number', __channel__)
-
-headers = [['User-Agent', 'Mozilla/50.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0'],
-           ['Referer', host]]
-
-parameters = channeltools.get_channel_parameters(__channel__)
-fanart_host = parameters['fanart']
-thumbnail_host = parameters['thumbnail']
-
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream','openload','rapidvideo','streamango'] # per l'autoplay
-list_quality = ['default'] #'rapidvideo', 'streamango', 'openload', 'streamcherry'] # per l'autoplay
-
-
-# =========== home menu ===================
-
-def mainlist(item):
-    """
-    Creo il menu principale del canale
-    :param item:
-    :return: itemlist []
-    """
-    logger.info("%s mainlist log: %s" % (__channel__, item)) 
-    itemlist = []
-
-    autoplay.init(item.channel, list_servers, list_quality)
-
-    # Menu Principale
-    support.menu(itemlist, 'Film Ultimi Arrivi bold', 'peliculas', host, args='pellicola')
-    support.menu(itemlist, 'Genere', 'categorie', host, args='genres')
-    support.menu(itemlist, 'Per anno submenu', 'categorie', host, args=['Film per Anno','years'])
-    support.menu(itemlist, 'Per lettera', 'categorie', host + '/catalog/a/', args=['Film per Lettera','orderalf'])
-    support.menu(itemlist, 'Al Cinema bold', 'peliculas', host + '/cinema/', args='pellicola')
-    support.menu(itemlist, 'Sub-ITA bold', 'peliculas', host + '/sub-ita/', args='pellicola')
-    support.menu(itemlist, 'Cerca film submenu', 'search', host)
-
-    autoplay.show_option(item.channel, itemlist)
-    
-    return itemlist
-
-# ======== def in ordine di menu ===========================
-# =========== def per vedere la lista dei film =============
-
-def peliculas(item):
-    logger.info("%s mainlist peliculas log: %s" % (__channel__, item))
-    itemlist = []
-    # scarico la pagina
-    data = httptools.downloadpage(item.url, headers=headers).data
-    # da qui fare le opportuni modifiche
-    if item.args != 'orderalf':
-        if item.args == 'pellicola' or item.args == 'years':
-            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)<div id="right_bar">')
-        elif item.args == "search":
-            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)</a>')
-        else:
-            bloque = scrapertools.find_single_match(data, '<div class="cover boxcaption">(.*?)<div class="page_nav">')
-        patron = '<h2>.<a href="(.*?)".*?src="(.*?)".*?class="trdublaj">(.*?)<div class="ml-item-hiden".*?class="h4">(.*?)<.*?label">(.*?)</span'
-        matches = scrapertools.find_multiple_matches(data, patron)
-        for scrapedurl, scrapedimg, scrapedqualang, scrapedtitle, scrapedyear in matches:
-
-            if 'sub ita' in scrapedqualang.lower():
-                scrapedlang = 'Sub-Ita'
-            else:
-                scrapedlang = 'ITA'
-            itemlist.append(Item(
-                channel=item.channel,
-                action="findvideos",
-                contentTitle=scrapedtitle,
-                fulltitle=scrapedtitle,
-                url=scrapedurl,
-                infoLabels={'year': scrapedyear},
-                contenType="movie",
-                thumbnail=host+scrapedimg,
-                title= "%s [%s]" % (scrapedtitle, scrapedlang),
-                language=scrapedlang
-                ))
-
-    # poichè  il sito ha l'anno del film con TMDB la ricerca titolo-anno è esatta quindi inutile fare lo scrap delle locandine 
-    # e della trama dal sito che a volte toppano
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Paginazione
-    support.nextPage(itemlist,item,data,'<span>[^<]+</span>[^<]+<a href="(.*?)">')
-    
-    return itemlist
-
-# =========== def pagina categorie ======================================
-
-def categorie(item):
-    logger.info("%s mainlist categorie log: %s" % (__channel__, item))
-    itemlist = []
-    # scarico la pagina
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    # da qui fare le opportuni modifiche
-    if item.args == 'genres':
-        bloque = scrapertools.find_single_match(data, '<ul class="kategori_list">(.*?)</ul>')
-        patron = '<li><a href="/(.*?)">(.*?)</a>'
-    elif item.args[1] == 'years':
-        bloque = scrapertools.find_single_match(data, '<ul class="anno_list">(.*?)</ul>')
-        patron = '<li><a href="/(.*?)">(.*?)</a>'
-    elif item.args[1] == 'orderalf':
-        bloque = scrapertools.find_single_match(data, '<div class="movies-letter">(.*)<div class="clearfix">')
-        patron = '<a title=.*?href="(.*?)"><span>(.*?)</span>'
-
-    matches = scrapertools.find_multiple_matches(bloque, patron)
-
-    for scrapurl, scraptitle in sorted(matches):
-
-        if "01" in scraptitle:
-          continue
-        else:
-          scrapurl = host+scrapurl
-
-        if item.args[1] != 'orderalf': action = "peliculas"
-        else: action = 'orderalf'
-        itemlist.append(Item(
-            channel=item.channel,
-            action= action,
-            title = scraptitle,
-            url= scrapurl,
-            thumbnail = get_thumb(scraptitle, auto = True),
-            extra = item.extra,
-        ))
-
-    return itemlist
-
-# =========== def pagina lista alfabetica ===============================
-
-def orderalf(item):
-    logger.info("%s mainlist orderalf log: %s" % (__channel__, item))
-    itemlist = []
-    # scarico la pagina
-    data = httptools.downloadpage(item.url, headers=headers).data
-    # da qui fare le opportuni modifiche
-    patron = '<td class="mlnh-thumb"><a href="(.*?)".title="(.*?)".*?src="(.*?)".*?mlnh-3">(.*?)<.*?"mlnh-5">.<(.*?)<td' #scrapertools.find_single_match(data, '<td class="mlnh-thumb"><a href="(.*?)".title="(.*?)".*?src="(.*?)".*?mlnh-3">(.*?)<.*?"mlnh-5">.<(.*?)<td')
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for scrapedurl, scrapedtitle, scrapedimg, scrapedyear, scrapedqualang in matches:
-
-            if 'sub ita' in scrapedqualang.lower():
-                scrapedlang = 'Sub-ita'
-            else:
-                scrapedlang = 'ITA'
-            itemlist.append(Item(
-                channel=item.channel,
-                action="findvideos_film",
-                contentTitle=scrapedtitle,
-                fulltitle=scrapedtitle,
-                url=scrapedurl,
-                infoLabels={'year': scrapedyear},
-                contenType="movie",
-                thumbnail=host+scrapedimg,
-                title = "%s [%s]" % (scrapedtitle, scrapedlang),
-                language=scrapedlang,
-                context="buscar_trailer"
-            ))
-
-    # se il sito permette l'estrazione dell'anno del film aggiungere la riga seguente
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Paginazione
-    support.nextPage(itemlist,item,data,'<span>[^<]+</span>[^<]+<a href="(.*?)">')
-
-    return itemlist
-
-# =========== def pagina del film con i server per verderlo =============
-
-def findvideos(item):
-    logger.info("%s mainlist findvideos_film log: %s" % (__channel__, item))
-    itemlist = []
-
-    # scarico la pagina
-    data = httptools.downloadpage(item.url, headers=headers).data
-    # da qui fare le opportuni modifiche
-    patron = '<a href="#" data-link="(.*?)">'
-    matches = scrapertools.find_multiple_matches(data, patron)
-
-    for scrapedurl in matches:
-        logger.info("altadefinizione01_club scrapedurl log: %s" % scrapedurl)
-        try:
-            itemlist = servertools.find_video_items(data=data)
-
-            for videoitem in itemlist:
-                logger.info("Videoitemlist2: %s" % videoitem)
-                videoitem.title = "%s [%s]" % (item.contentTitle, videoitem.title)
-                videoitem.show = item.show
-                videoitem.contentTitle = item.contentTitle
-                videoitem.contentType = item.contentType
-                videoitem.channel = item.channel
-                videoitem.year = item.infoLabels['year']
-                videoitem.infoLabels['plot'] = item.infoLabels['plot']
-        except AttributeError:
-            logger.error("data doesn't contain expected URL")
-
-    # Controlla se i link sono validi
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # Requerido para FilterTools
-    itemlist = filtertools.get_links(itemlist, item, list_language)
-
-    # Requerido para AutoPlay
-    autoplay.start(itemlist, item)
-
-    # Aggiunge alla videoteca
-    if  item.extra != 'findvideos' and item.extra != "library" and config.get_videolibrary_support() and len(itemlist) != 0 :
-       support.videolibrary(itemlist, item)
-    
-    return itemlist
-
-# =========== def per cercare film/serietv =============
-#http://altadefinizione01.link/index.php?do=search&story=avatar&subaction=search
-def search(item, text):
-    logger.info("%s mainlist search log: %s %s" % (__channel__, item, text))
-    itemlist = []
-    text = text.replace(" ", "+")
-    item.url = host + "/index.php?do=search&story=%s&subaction=search" % (text)
-    #item.extra = "search"
-    try:
-        return peliculas(item)
-    # 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("%s Sono qua: %s" % (__channel__, line))
-        return []
-
-# =========== def per le novità nel menu principale =============
-
-def newest(categoria):
-    logger.info("%s mainlist newest log: %s %s %s" % (__channel__, categoria))
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "film":
-            item.url = host
-            item.action = "peliculas"
-            itemlist = peliculas(item)
-            if itemlist[-1].action == "peliculas":
-                itemlist.pop()
-
-    # Continua la ricerca in caso di errore
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("{0}".format(line))
-        return []
-
-    return itemlist

channels/altadefinizione01_link.json

@@ -1,104 +0,0 @@
-{
-  "id": "altadefinizione01_link",
-  "name": "Altadefinizione01 L",
-  "active": true,
-  "adult": false,
-  "language": ["ita"],
-  "fanart": "https://altadefinizione01.estate/templates/Dark/img/nlogo.png",
-  "thumbnail": "https://altadefinizione01.estate/templates/Dark/img/nlogo.png",
-  "banner": "https://altadefinizione01.estate/templates/Dark/img/nlogo.png",
-  "fix" : "reimpostato url e modificato file per KOD",
-  "change_date": "2019-30-04",
-  "categories": [
-    "movie",
-    "vosi"
-  ],
-  "settings": [
-    {
-    "id": "channel_host",
-    "type": "text",
-    "label": "Host del canale",
-    "default": "https://altadefinizione01.estate/",
-    "enabled": true,
-    "visible": true
-    },  
-    {
-      "id": "modo_grafico",
-      "type": "bool",
-      "label": "Cerca informazioni extra",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_peliculas",
-      "type": "bool",
-      "label": "Includi in Novità",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_italiano",
-      "type": "bool",
-      "label": "Includi in Novità - Italiano",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },   
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Includi ricerca globale",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "checklinks",
-      "type": "bool",
-      "label": "Verifica se i link esistono",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "checklinks_number",
-      "type": "list",
-      "label": "Numero de link da verificare",
-      "default": 1,
-      "enabled": true,
-      "visible": "eq(-1,true)",
-      "lvalues": [ "5", "10", "15", "20" ]
-    },
-    {
-      "id": "filter_languages",
-      "type": "list",
-      "label": "Mostra link in lingua...",
-      "default": 0,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "Non filtrare",
-        "ITA",
-        "vosi"
-      ]
-    },
-    {
-      "id": "perfil",
-      "type": "list",
-      "label": "profilo dei colori",
-      "default": 0,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "Sin color",
-        "Perfil 5",
-        "Perfil 4",
-        "Perfil 3",
-        "Perfil 2",
-        "Perfil 1"
-      ]
-    }
-	  ]
-}

channels/altadefinizione01_link.py

@@ -1,147 +0,0 @@
-# -*- coding: utf-8 -*-
-# -*- Channel Altadefinizione01L Film - Serie -*-
-# -*- By Greko -*-
-
-import channelselector
-from specials import autoplay
-from core import servertools, support, jsontools
-from core.item import Item
-from platformcode import config, logger
-
-__channel__ = "altadefinizione01_link"
-
-# ======== def per utility INIZIO ============================
-
-list_servers = ['supervideo', 'streamcherry','rapidvideo', 'streamango', 'openload']
-list_quality = ['default']
-
-host = config.get_setting("channel_host", __channel__)
-
-headers = [['Referer', host]]
-# =========== home menu ===================
-
-def mainlist(item):
-    """
-    Creo il menu principale del canale
-    :param item:
-    :return: itemlist []
-    """
-    support.log()
-    itemlist = []
-
-    # Menu Principale
-    support.menu(itemlist, 'Novità bold', 'peliculas', host)
-    support.menu(itemlist, 'Film per Genere', 'genres', host, args='genres')
-    support.menu(itemlist, 'Film per Anno submenu', 'genres', host, args='years')
-    support.menu(itemlist, 'Film per Qualità submenu', 'genres', host, args='quality') 
-    support.menu(itemlist, 'Al Cinema bold', 'peliculas', host + '/film-del-cinema')
-    support.menu(itemlist, 'Popolari bold', 'peliculas', host + '/piu-visti.html')
-    support.menu(itemlist, 'Mi sento fortunato bold', 'genres', host, args='lucky')    
-    support.menu(itemlist, 'Sub-ITA bold', 'peliculas', host + '/film-sub-ita/')
-    support.menu(itemlist, 'Cerca film submenu', 'search', host)
-
-    # per autoplay
-    autoplay.init(item.channel, list_servers, list_quality)
-    autoplay.show_option(item.channel, itemlist)
-
-    support.channel_config(item, itemlist)
-    
-    return itemlist
-
-# ======== def in ordine di action dal menu ===========================
-
-def peliculas(item):
-    support.log
-    itemlist = []
-
-    patron = r'class="innerImage">.*?href="([^"]+)".*?src="([^"]+)"'\
-             '.*?class="ml-item-title">([^<]+)</.*?class="ml-item-label"> (\d{4}) <'\
-             '.*?class="ml-item-label">.*?class="ml-item-label ml-item-label-.+?"> '\
-             '(.+?) </div>.*?class="ml-item-label"> (.+?) </'
-    listGroups = ['url', 'thumb', 'title', 'year', 'quality', 'lang']
-
-    patronNext =  '<span>\d</span> <a href="([^"]+)">'
-    
-    itemlist = support.scrape(item, patron=patron, listGroups=listGroups,
-                          headers= headers, patronNext=patronNext,
-                          action='findvideos')    
-    
-    return itemlist
-
-# =========== def pagina categorie ======================================
-
-def genres(item):
-    support.log
-    itemlist = []
-    #data = httptools.downloadpage(item.url, headers=headers).data
-    action = 'peliculas'
-    if item.args == 'genres':
-        bloque = r'<ul class="listSubCat" id="Film">(.*?)</ul>'
-    elif item.args == 'years':
-        bloque = r'<ul class="listSubCat" id="Anno">(.*?)</ul>'
-    elif item.args == 'quality':
-        bloque = r'<ul class="listSubCat" id="Qualita">(.*?)</ul>'
-    elif item.args == 'lucky': # sono i titoli random nella pagina, cambiano 1 volta al dì
-        bloque = r'FILM RANDOM.*?class="listSubCat">(.*?)</ul>'
-        action = 'findvideos'
-     
-    patron = r'<li><a href="([^"]+)">(.*?)<'
-
-    listGroups = ['url','title']
-    itemlist = support.scrape(item, patron=patron, listGroups=listGroups,
-                          headers= headers, patron_block = bloque,
-                          action=action)    
-
-    return itemlist
-
-# =========== def per cercare film/serietv =============
-#host+/index.php?do=search&story=avatar&subaction=search
-def search(item, text):
-    support.log()
-    itemlist = []
-    text = text.replace(" ", "+")
-    item.url = host+"/index.php?do=search&story=%s&subaction=search" % (text)
-    try:
-        return peliculas(item)
-    # Se captura la excepciÛn, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.info("%s mainlist search log: %s" % (__channel__, line))
-        return []
-
-# =========== def per le novità nel menu principale =============
-
-def newest(categoria):
-    support.log(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():
-            logger.error("{0}".format(line))
-        return []
-
-    return itemlist
-
-def findvideos(item):
-    support.log()
-    
-    itemlist = support.server(item, headers=headers)
-
-    # Requerido para FilterTools
-    # itemlist = filtertools.get_links(itemlist, item, list_language)
-
-    # Requerido para AutoPlay
-    autoplay.start(itemlist, item)
-    
-    return itemlist

channels/altadefinizioneclick.json

@@ -1,78 +1,11 @@
 {
     "id": "altadefinizioneclick",
     "name": "AltadefinizioneClick",
-    "active": true,
-    "adult": false,
-    "language": ["ita"],
-    "thumbnail": "https:\/\/raw.githubusercontent.com\/Zanzibar82\/images\/master\/posters\/altadefinizioneclick.png",
-    "bannermenu": "https:\/\/raw.githubusercontent.com\/Zanzibar82\/images\/master\/posters\/altadefinizioneciclk.png",
-    "categories": ["movie","vosi"],
-    "settings": [
-        {
-            "id": "channel_host",
-            "type": "text",
-            "label": "Host del canale",
-            "default": "https://altadefinizione.cloud",
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },		
-        {
-            "id": "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": [ "5", "10", "15", "20" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
+    "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

@@ -1,112 +1,151 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Canale per altadefinizioneclick
+# Canale per Altadefinizione Click
 # ----------------------------------------------------------
 
-import re
+from core import support
+from platformcode import config, logger
 
-from core import servertools, support
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
+def findhost(url):
+    return support.match(url, patron=r'<div class="elementor-button-wrapper">\s*<a href="([^"]+)"').match
 
-#host = config.get_setting("channel_host", 'altadefinizioneclick')
-__channel__ = 'altadefinizioneclick'
-host = config.get_channel_url(__channel__)
+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')]
 
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream', 'openload', 'streamango', "vidoza", "thevideo", "okru", 'youtube']
-list_quality = ['1080p']
-
-checklinks = config.get_setting('checklinks', 'altadefinizioneclick')
-checklinks_number = config.get_setting('checklinks_number', 'altadefinizioneclick')
-
-headers = [['Referer', host]]
 
+@support.menu
 def mainlist(item):
-    support.log()    
-    itemlist = []
+    logger.debug(item)
 
-    support.menu(itemlist, 'Film', 'peliculas', host + "/nuove-uscite/")
-    support.menu(itemlist, 'Per Genere submenu', 'menu', host, args='Film')
-    support.menu(itemlist, 'Per Anno submenu', 'menu', host, args='Anno')
-    support.menu(itemlist, 'Sub-ITA', 'peliculas', host + "/sub-ita/")
-    support.menu(itemlist, 'Cerca...', 'search', host, 'movie')    
-    support.aplay(item, itemlist,list_servers, list_quality)
-    support.channel_config(item, itemlist)
+    film = ['/type/movie',
+            ('Generi', ['/type/movie', 'genres', 'genres']),
+            ('Anni', ['/type/movie', 'genres', 'year']),]
 
-    return itemlist
+    tvshow = ['/serie-tv/tvshow',
+              ('Generi', ['/serie-tv/tvshow', 'genres', 'genres']),
+              ('Anni', ['/serie-tv/tvshow', 'genres', 'year'])]
+
+    return locals()
 
 
 def search(item, texto):
-    support.log("search ", texto)
-
-    item.extra = 'search'
-    item.url = host + "/?s=" + 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 
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
-            logger.error("%s" % line)
+            support.logger.error("%s" % line)
         return []
 
-def newest(categoria):
-    support.log(categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "peliculas":
-            item.url = host + "/nuove-uscite/"
-            item.action = "peliculas"
-            itemlist = peliculas(item)
 
-            if itemlist[-1].action == "peliculas":
-                itemlist.pop()
+@support.scrape
+def genres(item):
+    logger.debug(item)
+    data = support.httptools.downloadpage(item.url, cloudscraper=True).data
+    blacklist= ['Film', 'Serie TV']
 
-    # Continua la ricerca in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("{0}".format(line))
-        return []
+    if item.args == 'genres':
+        categories ={}
+        res = support.match(host + '/cerca', patron=r'for="cat-(\d+)[^>]+>([^<]+)').matches
+        for _id, name in res:
+            categories[name] = _id
 
-    return itemlist
+        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()
 
 
-def menu(item):
-    support.log()
-    itemlist = support.scrape(item, '<li><a href="([^"]+)">([^<]+)</a></li>', ['url', 'title'], headers,  patron_block='<ul class="listSubCat" id="'+ str(item.args) + '">(.*?)</ul>', action='peliculas')
-    return support.thumb(itemlist)
-
+@support.scrape
 def peliculas(item):
-    support.log()
-    if item.extra == 'search':
-        patron = r'<a href="([^"]+)">\s*<div class="wrapperImage">(?:<span class="hd">([^<]+)<\/span>)?<img[^s]+src="([^"]+)"[^>]+>[^>]+>[^>]+>([^<]+)<[^<]+>(?:.*?IMDB:\s([^<]+)<\/div>)?'
-        elements = ['url', 'quality', 'thumb', 'title', 'rating']
-        
+    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:
-        patron = r'<img width[^s]+src="([^"]+)[^>]+><\/a>.*?<a href="([^"]+)">([^(?:\]|<)]+)(?:\[([^\]]+)\])?<\/a>[^>]+>[^>]+>[^>]+>(?:\sIMDB\:\s([^<]+)<)?(?:.*?<span class="hd">([^<]+)<\/span>)?\s*<a'
-        elements =['thumb', 'url', 'title','lang', 'rating', 'quality']
-    itemlist = support.scrape(item, patron, elements, headers, patronNext='<a class="next page-numbers" href="([^"]+)">')
-    return itemlist
+        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):
-    support.log()
+    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=''))
 
-    itemlist = support.hdpass_get_servers(item)
 
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # itemlist = filtertools.get_links(itemlist, item, list_language)
-
-    autoplay.start(itemlist, item)
-    support.videolibrary(itemlist, item ,'color kod bold')
-
-    return itemlist
+    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/altadefinizionehd.json

@@ -1,70 +0,0 @@
-{
-    "id": "altadefinizionehd",
-    "name": "AltadefinizioneHD",
-    "active": false,
-    "adult": false,
-    "language": ["ita"],
-    "thumbnail": "https://altadefinizione.doctor/wp-content/uploads/2019/02/logo.png",
-    "bannermenu": "https://altadefinizione.doctor/wp-content/uploads/2019/02/logo.png",
-    "categories": ["tvshow","movie"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi in Ricerca Globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_series",
-            "type": "bool",
-            "label": "Includi in Novità - Serie TV",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "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": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
-}

channels/altadefinizionehd.py

@@ -1,264 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per Altadefinizione HD
-# ----------------------------------------------------------
-import re
-
-from channelselector import thumb
-from core import httptools, scrapertools, servertools, tmdb
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
-
-__channel__ = 'altadefinizionehd'
-host = config.get_channel_url(__channel__)
-
-headers = [['Referer', host]]
-
-list_servers = ['openload']
-list_quality = ['default']
-
-def mainlist(item):
-    logger.info("[altadefinizionehd.py] mainlist")
-
-    autoplay.init(item.channel, list_servers, list_quality)
-
-    itemlist = [Item(channel=item.channel,
-                     action="video",
-                     title="[B]Film[/B]",
-                     url=host + '/movies/',
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="menu",
-                     title="[B] > Film per Genere[/B]",
-                     url=host,
-                     extra='GENERE',
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="menu",
-                     title="[B] > Film per Anno[/B]",
-                     url=host,
-                     extra='ANNO',
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="video",
-                     title="Film Sub-Ita",
-                     url=host + "/genre/sub-ita/",
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="video",
-                     title="Film Rip",
-                     url=host + "/genre/dvdrip-bdrip-brrip/",
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="video",
-                     title="Film al Cinema",
-                     url=host + "/genre/cinema/",
-                     thumbnail=NovitaThumbnail,
-                     fanart=FilmFanart),
-                Item(channel=item.channel,
-                     action="search",
-                     extra="movie",
-                     title="[COLOR blue]Cerca Film...[/COLOR]",
-                     thumbnail=CercaThumbnail,
-                     fanart=FilmFanart)]
-
-    autoplay.show_option(item.channel, itemlist)
-
-    itemlist = thumb(itemlist)
-
-    return itemlist
-
-
-def menu(item):
-    logger.info("[altadefinizionehd.py] menu")
-    itemlist = []
-    data = httptools.downloadpage(item.url, headers=headers).data
-    logger.info("[altadefinizionehd.py] DATA"+data)
-    patron = r'<li id="menu.*?><a href="#">FILM PER ' + item.extra + r'<\/a><ul class="sub-menu">(.*?)<\/ul>'
-    logger.info("[altadefinizionehd.py] BLOCK"+patron)
-    block = scrapertools.find_single_match(data, patron)
-    logger.info("[altadefinizionehd.py] BLOCK"+block)
-    patron = r'<li id=[^>]+><a href="(.*?)">(.*?)<\/a><\/li>'
-    matches = re.compile(patron, re.DOTALL).findall(block)
-    for url, title in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-            action='video',
-            title=title,
-            url=url))
-    return itemlist
-
-
-
-def newest(categoria):
-    logger.info("[altadefinizionehd.py] newest" + categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "peliculas":
-            item.url = host
-            item.action = "video"
-            itemlist = video(item)
-
-            if itemlist[-1].action == "video":
-                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 video(item):
-    logger.info("[altadefinizionehd.py] video")
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-    logger.info("[altadefinizionehd.py] Data" +data)
-    if 'archive-content' in data:
-        regex = r'<div id="archive-content".*?>(.*?)<div class="pagination'
-    else:
-        regex = r'<div class="items".*?>(.*?)<div class="pagination'
-    block = scrapertools.find_single_match(data, regex)
-    logger.info("[altadefinizionehd.py] Block" +block)
-    
-    patron = r'<article .*?class="item movies">.*?<img src="([^"]+)".*?<span class="quality">(.*?)<\/span>.*?<a href="([^"]+)">.*?<h4>([^<]+)<\/h4>(.*?)<\/article>'
-    matches = re.compile(patron, re.DOTALL).findall(block)
-
-    for scrapedthumb, scrapedquality, scrapedurl, scrapedtitle, scrapedinfo in matches:
-        title = scrapedtitle + " [" + scrapedquality + "]"
-        
-        patron = r'IMDb: (.*?)<\/span> <span>(.*?)<\/span>.*?"texto">(.*?)<\/div>'
-        matches = re.compile(patron, re.DOTALL).findall(scrapedinfo)
-        logger.info("[altadefinizionehd.py] MATCHES" + str(matches))
-        for rating, year, plot in matches:
-        
-            infoLabels = {}
-            infoLabels['Year'] = year
-            infoLabels['Rating'] = rating
-            infoLabels['Plot'] = plot
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="findvideos",
-                    contentType="movie",
-                    title=title,
-                    fulltitle=scrapedtitle,
-                    infoLabels=infoLabels,
-                    url=scrapedurl,
-                    thumbnail=scrapedthumb))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    patron = '<a class='+ "'arrow_pag'" + ' href="([^"]+)"'
-    next_page = scrapertools.find_single_match(data, patron)
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="video",
-                 title="[COLOR blue]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=next_page,
-                 thumbnail=thumb()))
-
-    return itemlist
-
-
-def search(item, texto):
-    logger.info("[altadefinizionehd.py] init texto=[" + texto + "]")
-    item.url = host + "/?s=" + texto
-    return search_page(item)
-
-def search_page(item):
-        itemlist = []
-        data = httptools.downloadpage(item.url, headers=headers).data
-
-        patron = r'<img src="([^"]+)".*?.*?<a href="([^"]+)">(.*?)<\/a>'
-        matches = re.compile(patron, re.DOTALL).findall(data)
-
-        for scrapedthumbnail, scrapedurl, scrapedtitle in matches:
-            scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="findvideos",
-                    title=scrapedtitle,
-                    fulltitle=scrapedtitle,
-                    url=scrapedurl,
-                    thumbnail=scrapedthumbnail))
-
-        tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-        patron = '<a class='+ "'arrow_pag'" + ' href="([^"]+)"'
-        next_page = scrapertools.find_single_match(data, patron)
-        if next_page != "":
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="search_page",
-                    title="[COLOR blue]" + config.get_localized_string(30992) + "[/COLOR]",
-                    url=next_page,
-                    thumbnail=thumb()))
-    
-        return itemlist    
-
-
-def findvideos(item):
-    data = httptools.downloadpage(item.url).data
-    patron = r"<li id='player-.*?'.*?class='dooplay_player_option'\sdata-type='(.*?)'\sdata-post='(.*?)'\sdata-nume='(.*?)'>.*?'title'>(.*?)</"
-    matches = re.compile(patron, re.IGNORECASE).findall(data)
-
-    itemlist = []
-
-    for scrapedtype, scrapedpost, scrapednume, scrapedtitle in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="play",
-                 fulltitle=item.title + " [" + scrapedtitle + "]",
-                 show=scrapedtitle,
-                 title=item.title + " [COLOR blue][" + scrapedtitle + "][/COLOR]",
-                 url=host + "/wp-admin/admin-ajax.php",
-                 post=scrapedpost,
-                 server=scrapedtitle,
-                 nume=scrapednume,
-                 type=scrapedtype,
-                 extra=item.extra,
-                 folder=True))
-
-    autoplay.start(itemlist, item)
-
-    return itemlist
-
-def play(item):
-    import urllib
-    payload = urllib.urlencode({'action': 'doo_player_ajax', 'post': item.post, 'nume': item.nume, 'type': item.type})
-    data = httptools.downloadpage(item.url, post=payload).data
-
-    patron = r"<iframe.*src='(([^']+))'\s"
-    matches = re.compile(patron, re.IGNORECASE).findall(data)
-
-    url = matches[0][0]
-    url = url.strip()
-    data = httptools.downloadpage(url, headers=headers).data
-
-    itemlist = servertools.find_video_items(data=data)
-
-    return itemlist
-
-
-
-NovitaThumbnail = "https://superrepo.org/static/images/icons/original/xplugin.video.moviereleases.png.pagespeed.ic.j4bhi0Vp3d.png"
-GenereThumbnail = "https://farm8.staticflickr.com/7562/15516589868_13689936d0_o.png"
-FilmFanart = "https://superrepo.org/static/images/fanart/original/script.artwork.downloader.jpg"
-CercaThumbnail = "http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search"
-CercaFanart = "https://i.ytimg.com/vi/IAlbvyBdYdY/maxresdefault.jpg"
-ListTxt = "[COLOR orange]Torna a video principale [/COLOR]"
-AvantiTxt = config.get_localized_string(30992)
-AvantiImg = "http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"
-thumbnail = "http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"

channels/analdin.json

@@ -1,15 +0,0 @@
-{
-  "id": "analdin",
-  "name": "analdin",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "https://www.analdin.com/images/logo-retina.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-
-  ]
-}

channels/analdin.py

@@ -1,113 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'https://www.analdin.com/es'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Nuevas" , action="lista", url=host + "/más-reciente/"))
-    itemlist.append( Item(channel=item.channel, title="Mas Vistas" , action="lista", url=host + "/más-visto/"))
-    itemlist.append( Item(channel=item.channel, title="Mejor valorada" , action="lista", url=host + "/mejor-valorado/"))
-    itemlist.append( Item(channel=item.channel, title="Canal" , action="catalogo", url=host))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/categorías/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/?s=%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def catalogo(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = scrapertools.find_single_match(data,'<strong class="popup-title">Canales</strong>(.*?)<strong>Models</strong>')
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron  = '<li><a class="item" href="([^"]+)" title="([^"]+)">'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle in matches:
-        scrapedplot = ""
-        scrapedthumbnail = ""
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    next_page = scrapertools.find_single_match(data,'<li class="arrow"><a rel="next" href="([^"]+)">&raquo;</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="catalogo", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<a class="item" href="([^"]+)" title="([^"]+)">.*?'
-    patron += 'src="([^"]+)".*?'
-    patron += '<div class="videos">([^"]+)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,cantidad in matches:
-        scrapedplot = ""
-        scrapedtitle = scrapedtitle + " (" + cantidad + ")"
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl)
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail,  thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return sorted(itemlist, key=lambda i: i.title)
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<a class="popup-video-link" href="([^"]+)".*?'
-    patron += 'thumb="([^"]+)".*?'
-    patron += '<div class="duration">(.*?)</div>.*?'
-    patron += '<strong class="title">\s*([^"]+)</strong>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtime,scrapedtitle  in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail, plot=plot,
-                              fanart=thumbnail, contentTitle = title))
-    next_page = scrapertools.find_single_match(data,'<li class="next"><a href="([^"]+)"')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append( Item(channel=item.channel, action="lista", title="Página Siguiente >>", text_color="blue",
-                              url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = 'video_url: \'([^\']+)\''
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl  in matches:
-        url = scrapedurl
-    itemlist.append(item.clone(action="play", title=url, fulltitle = item.title, url=url))
-    return itemlist
-

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

@@ -2,19 +2,18 @@
 	"id": "animeforce",
 	"name": "AnimeForce",
 	"language": ["ita"],
-	"active": true,
-	"adult": false,
-	"thumbnail": "http://www.animeforce.org/wp-content/uploads/2013/05/logo-animeforce.png",
-	"banner": "http://www.animeforce.org/wp-content/uploads/2013/05/logo-animeforce.png",
+	"active": false,
+	"thumbnail": "animeforce.png",
+	"banner": "animeforce.png",
 	"categories": ["anime"],
 	"settings": [
         {
             "id": "include_in_global_search",
             "type": "bool",
-            "label": "Incluir en busqueda global",
+            "label": "Includi in Ricerca Globale",
             "default": false,
             "enabled": false,
-            "visible": false
+            "visible": true
         },
         {
             "id": "include_in_newest_anime",
@@ -25,12 +24,37 @@
             "visible": true
         },
         {
-            "id": "include_in_newest_italiano",
+            "id": "checklinks",
             "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
+            "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

@@ -1,505 +1,162 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Ringraziamo Icarus crew
-# Canale per http://animeinstreaming.net/
+# Canale per AnimeForce
 # ------------------------------------------------------------
-import re
-import urllib
-import urlparse
 
-from core import httptools, scrapertools, servertools, tmdb
-from core.item import Item
-from platformcode import config, logger
-from servers.decrypters import adfly
-
-__channel__ = "animeforge"
-host = config.get_channel_url(__channel__)
-
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
+from core import support
 
+host = support.config.get_channel_url()
 headers = [['Referer', host]]
 
-PERPAGE = 20
 
-
-# -----------------------------------------------------------------
+@support.menu
 def mainlist(item):
-    log("mainlist", "mainlist", item.channel)
-    itemlist = [Item(channel=item.channel,
-                     action="lista_anime",
-                     title="[COLOR azure]Anime [/COLOR]- [COLOR lightsalmon]Lista Completa[/COLOR]",
-                     url=host + "/lista-anime/",
-                     thumbnail=CategoriaThumbnail,
-                     fanart=CategoriaFanart),
-                Item(channel=item.channel,
-                     action="animeaggiornati",
-                     title="[COLOR azure]Anime Aggiornati[/COLOR]",
-                     url=host,
-                     thumbnail=CategoriaThumbnail,
-                     fanart=CategoriaFanart),
-                Item(channel=item.channel,
-                     action="ultimiep",
-                     title="[COLOR azure]Ultimi Episodi[/COLOR]",
-                     url=host,
-                     thumbnail=CategoriaThumbnail,
-                     fanart=CategoriaFanart),
-                Item(channel=item.channel,
-                     action="search",
-                     title="[COLOR yellow]Cerca ...[/COLOR]",
-                     thumbnail="http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")]
-
-    return itemlist
+    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):
-    log("newest", "newest" + categoria)
+    support.info(categoria)
     itemlist = []
-    item = Item()
+    item = support.Item()
     try:
         if categoria == "anime":
+            item.contentType = 'tvshow'
             item.url = host
-            item.action = "ultimiep"
-            itemlist = ultimiep(item)
-
-            if itemlist[-1].action == "ultimiep":
-                itemlist.pop()
-    # Continua la ricerca in caso di errore 
+            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))
+            support.logger.error("{0}".format(line))
         return []
 
     return itemlist
 
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def search(item, texto):
-    log("search", "search", item.channel)
-    item.url = host + "/?s=" + texto
+def search(item, text):
+    support.info('search',text)
+    item.search = text
+    item.url = host + '/lista-anime/'
+    item.contentType = 'tvshow'
     try:
-        return search_anime(item)
-    # Continua la ricerca in caso di errore 
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
-            logger.error("%s" % line)
+            support.logger.error("%s" % line)
         return []
 
 
-# =================================================================
+@support.scrape
+def peliculas(item):
+    search = item.search
+    anime = True
+    action = 'check'
 
-# -----------------------------------------------------------------
-def search_anime(item):
-    log("search_anime", "search_anime", item.channel)
-    itemlist = []
+    patron = r'<a href="(?P<url>[^"]+)"[^>]+>\s*<img src="(?P<thumb>[^"]+)" alt="(?P<title>.*?)(?: Sub| sub| SUB|")'
 
-    data = httptools.downloadpage(item.url).data
+    if search:
+        patron = r'<a href="(?P<url>[^"]+)"\s*title="(?P<title>.*?)(?: Sub| sub| SUB|")'
 
-    patron = r'<a href="([^"]+)"><img.*?src="([^"]+)".*?title="([^"]+)".*?/>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
+    if item.args == 'newest': item.action = 'findvideos'
 
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        if "Sub Ita Download & Streaming" in scrapedtitle or "Sub Ita Streaming":
-            if 'episodio' in scrapedtitle.lower():
-                itemlist.append(episode_item(item, scrapedtitle, scrapedurl, scrapedthumbnail))
-            else:
-                scrapedtitle, eptype = clean_title(scrapedtitle, simpleClean=True)
-                cleantitle, eptype = clean_title(scrapedtitle)
+    patronNext = '<li class="page-item disabled">(?:[^>]+>){4}<a class="page-link" href="([^"]+)'
 
-                scrapedurl, total_eps = create_url(scrapedurl, cleantitle)
+    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
 
-                itemlist.append(
-                    Item(channel=item.channel,
-                        action="episodios",
-                        text_color="azure",
-                        contentType="tvshow",
-                        title=scrapedtitle,
-                        url=scrapedurl,
-                        fulltitle=cleantitle,
-                        show=cleantitle,
-                        thumbnail=scrapedthumbnail))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Next Page
-    next_page = scrapertools.find_single_match(data, r'<link rel="next" href="([^"]+)"[^/]+/>')
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="search_anime",
-                 text_bold=True,
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=next_page,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"))
-
-    return itemlist
+    return locals()
 
 
-# =================================================================
-
-# -----------------------------------------------------------------
-def animeaggiornati(item):
-    log("animeaggiornati", "animeaggiornati", item.channel)
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    patron = r'<img.*?src="([^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="([^"]+)">([^<]+)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedthumbnail, scrapedurl, scrapedtitle in matches:
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        if 'Streaming' in scrapedtitle:
-            cleantitle, eptype = clean_title(scrapedtitle)
-            
-            # Creazione URL
-            scrapedurl, total_eps = create_url(scrapedurl, scrapedtitle)
-
-            itemlist.append(
-                Item(channel=item.channel,
-                     action="episodios",
-                     text_color="azure",
-                     contentType="tvshow",
-                     title=cleantitle,
-                     url=scrapedurl,
-                     fulltitle=cleantitle,
-                     show=cleantitle,
-                     thumbnail=scrapedthumbnail))
-    
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    return itemlist
+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)
 
 
-# =================================================================
-
-# -----------------------------------------------------------------
-def ultimiep(item):
-    log("ultimiep", "ultimiep", item.channel)
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    patron = r'<img.*?src="([^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="([^"]+)">([^<]+)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedthumbnail, scrapedurl, scrapedtitle in matches:
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        if 'Streaming' in scrapedtitle:
-            itemlist.append(episode_item(item, scrapedtitle, scrapedurl, scrapedthumbnail))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    return itemlist
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def lista_anime(item):
-    log("lista_anime", "lista_anime", item.channel)
-
-    itemlist = []
-
-    p = 1
-    if '{}' in item.url:
-        item.url, p = item.url.split('{}')
-        p = int(p)
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
-
-    # Estrae i contenuti 
-    patron = r'<li>\s*<strong>\s*<a\s*href="([^"]+?)">([^<]+?)</a>\s*</strong>\s*</li>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    scrapedplot = ""
-    scrapedthumbnail = ""
-    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
-        if (p - 1) * PERPAGE > i: continue
-        if i >= p * PERPAGE: break
-
-        # Pulizia titolo
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle).strip()
-        cleantitle, eptype = clean_title(scrapedtitle, simpleClean=True)
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 extra=item.extra,
-                 action="episodios",
-                 text_color="azure",
-                 contentType="tvshow",
-                 title=cleantitle,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fulltitle=cleantitle,
-                 show=cleantitle,
-                 plot=scrapedplot,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    if len(matches) >= p * PERPAGE:
-        scrapedurl = item.url + '{}' + str(p + 1)
-        itemlist.append(
-            Item(channel=item.channel,
-                 extra=item.extra,
-                 action="lista_anime",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
-                 folder=True))
-
-    return itemlist
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
+@support.scrape
 def episodios(item):
-    itemlist = []
+    anime = True
+    pagination = 50
+    data = item.data
 
-    data = httptools.downloadpage(item.url).data
-
-    patron = '<td style="[^"]*?">\s*.*?<strong>(.*?)</strong>.*?\s*</td>\s*<td style="[^"]*?">\s*<a href="([^"]+?)"[^>]+>\s*<img.*?src="([^"]+?)".*?/>\s*</a>\s*</td>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    vvvvid_videos = False
-    for scrapedtitle, scrapedurl, scrapedimg in matches:
-        if 'nodownload' in scrapedimg or 'nostreaming' in scrapedimg:
-            continue
-        if 'vvvvid' in scrapedurl.lower():
-            if not vvvvid_videos: vvvvid_videos = True
-            itemlist.append(Item(title='I Video VVVVID Non sono supportati', text_color="red"))
-            continue
-
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        scrapedtitle = re.sub(r'<[^>]*?>', '', scrapedtitle)
-        scrapedtitle = '[COLOR azure][B]' + scrapedtitle + '[/B][/COLOR]'
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="episode",
-                 title=scrapedtitle,
-                 url=urlparse.urljoin(host, scrapedurl),
-                 fulltitle=scrapedtitle,
-                 show=scrapedtitle,
-                 plot=item.plot,
-                 fanart=item.fanart,
-                 thumbnail=item.thumbnail))
-
-    # Comandi di servizio
-    if config.get_videolibrary_support() and len(itemlist) != 0 and not vvvvid_videos:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title=config.get_localized_string(30161),
-                 text_color="yellow",
-                 text_bold=True,
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
-
-    return itemlist
+    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):
-    logger.info("kod.animeforce findvideos")
-
+    support.info(item)
     itemlist = []
-
-    if item.extra:
-        data = httptools.downloadpage(item.url, headers=headers).data
-
-        blocco = scrapertools.find_single_match(data, r'%s(.*?)</tr>' % item.extra)
-        url = scrapertools.find_single_match(blocco, r'<a href="([^"]+)"[^>]*>')
-        if 'vvvvid' in url.lower():
-            itemlist = [Item(title='I Video VVVVID Non sono supportati', text_color="red")]
-            return itemlist
-        if 'http' not in url: url = "".join(['https:', url])
+    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 url:
-        url = adfly.get_long_url(url)
-    elif 'bit.ly' in url:
-        url = httptools.downloadpage(url, only_headers=True, follow_redirects=False).headers.get("location")
+    # if 'adf.ly' in item.url:
+    #     from servers.decrypters import adfly
+    #     url = adfly.get_long_url(item.url)
 
-    if 'animeforce' in url:
-        headers.append(['Referer', item.url])
-        data = httptools.downloadpage(url, headers=headers).data
-        itemlist.extend(servertools.find_video_items(data=data))
+    # elif 'bit.ly' in item.url:
+    #     url = support.httptools.downloadpage(item.url, only_headers=True, follow_redirects=False).headers.get("location")
 
-        for videoitem in itemlist:
-            videoitem.title = item.title + videoitem.title
-            videoitem.fulltitle = item.fulltitle
-            videoitem.show = item.show
-            videoitem.thumbnail = item.thumbnail
-            videoitem.channel = item.channel
-            videoitem.contentType = item.contentType
-
-        url = url.split('&')[0]
-        data = httptools.downloadpage(url, headers=headers).data
-        patron = """<source\s*src=(?:"|')([^"']+?)(?:"|')\s*type=(?:"|')video/mp4(?:"|')>"""
-        matches = re.compile(patron, re.DOTALL).findall(data)
-        headers.append(['Referer', url])
-        for video in matches:
-            itemlist.append(Item(channel=item.channel, action="play", title=item.title,
-                                 url=video + '|' + urllib.urlencode(dict(headers)), folder=False))
-    else:
-        itemlist.extend(servertools.find_video_items(data=url))
-
-        for videoitem in itemlist:
-            videoitem.title = item.title + videoitem.title
-            videoitem.fulltitle = item.fulltitle
-            videoitem.show = item.show
-            videoitem.thumbnail = item.thumbnail
-            videoitem.channel = item.channel
-            videoitem.contentType = item.contentType
-
-    return itemlist
+    # 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'))
 
-# =================================================================
-# Funzioni di servizio
-# -----------------------------------------------------------------
-def scrapedAll(url="", patron=""):
-    data = httptools.downloadpage(url).data
-    MyPatron = patron
-    matches = re.compile(MyPatron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    return matches
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def create_url(url, title, eptype=""):
-    logger.info()
-
-    if 'download' not in url:
-        url = url.replace('-streaming', '-download-streaming')
-
-    total_eps = ""
-    if not eptype:
-        url = re.sub(r'episodio?-?\d+-?(?:\d+-|)[oav]*', '', url)
-    else: # Solo se è un episodio passa
-        total_eps = scrapertools.find_single_match(title.lower(), r'\((\d+)-(?:episodio|sub-ita)\)') # Questo numero verrà rimosso dall'url
-        if total_eps: url = url.replace('%s-' % total_eps, '')
-        url = re.sub(r'%s-?\d*-' % eptype.lower(), '', url)
-    url = url.replace('-fine', '')
-
-    return url, total_eps
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def clean_title(title, simpleClean=False):
-    logger.info()
-
-    title = title.replace("Streaming", "").replace("&", "")
-    title = title.replace("Download", "")
-    title = title.replace("Sub Ita", "")
-    cleantitle = title.replace("#038;", "").replace("amp;", "").strip()
-
-    if '(Fine)' in title:
-        cleantitle = cleantitle.replace('(Fine)', '').strip() + " (Fine)"
-    eptype = ""
-    if not simpleClean:
-        if "episodio" in title.lower():
-            eptype = scrapertools.find_single_match(title, "((?:Episodio?|OAV))")
-            cleantitle = re.sub(r'%s\s*\d*\s*(?:\(\d+\)|)' % eptype, '', title).strip()
-
-            if 'episodio' not in eptype.lower():
-                cleantitle = re.sub(r'Episodio?\s*\d+\s*(?:\(\d+\)|)\s*[\(OAV\)]*', '', cleantitle).strip()
-
-            if '(Fine)' in title:
-                cleantitle = cleantitle.replace('(Fine)', '')
-
-    return cleantitle, eptype
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def episode_item(item, scrapedtitle, scrapedurl, scrapedthumbnail):
-    scrapedtitle, eptype = clean_title(scrapedtitle, simpleClean=True)
-    cleantitle, eptype = clean_title(scrapedtitle)
-
-    # Creazione URL
-    scrapedurl, total_eps = create_url(scrapedurl, scrapedtitle, eptype)
-
-    epnumber = ""
-    if 'episodio' in eptype.lower():
-        epnumber = scrapertools.find_single_match(scrapedtitle.lower(), r'episodio?\s*(\d+)')
-        eptype += ":? %s%s" % (epnumber, (r" \(%s\):?" % total_eps) if total_eps else "")
-
-    extra = "<tr>\s*<td[^>]+><strong>(?:[^>]+>|)%s(?:[^>]+>[^>]+>|[^<]*|[^>]+>)</strong>" % eptype
-    item = Item(channel=item.channel,
-         action="findvideos",
-         contentType="tvshow",
-         title=scrapedtitle,
-         text_color="azure",
-         url=scrapedurl,
-         fulltitle=cleantitle,
-         extra=extra,
-         show=cleantitle,
-         thumbnail=scrapedthumbnail)
-    return item
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def scrapedSingle(url="", single="", patron=""):
-    data = httptools.downloadpage(url).data
-    paginazione = scrapertools.find_single_match(data, single)
-    matches = re.compile(patron, re.DOTALL).findall(paginazione)
-    scrapertools.printMatches(matches)
-
-    return matches
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def Crea_Url(pagina="1", azione="ricerca", categoria="", nome=""):
-    # esempio
-    # chiamate.php?azione=ricerca&cat=&nome=&pag=
-    Stringa = host + "/chiamate.php?azione=" + azione + "&cat=" + categoria + "&nome=" + nome + "&pag=" + pagina
-    log("crea_Url", Stringa)
-    return Stringa
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def log(funzione="", stringa="", canale=""):
-    logger.debug("[" + canale + "].[" + funzione + "] " + stringa)
-
-
-# =================================================================
-
-# =================================================================
-# riferimenti di servizio
-# -----------------------------------------------------------------
-AnimeThumbnail = "http://img15.deviantart.net/f81c/i/2011/173/7/6/cursed_candies_anime_poster_by_careko-d3jnzg9.jpg"
-AnimeFanart = "https://i.ytimg.com/vi/IAlbvyBdYdY/maxresdefault.jpg"
-CategoriaThumbnail = "http://static.europosters.cz/image/750/poster/street-fighter-anime-i4817.jpg"
-CategoriaFanart = "https://i.ytimg.com/vi/IAlbvyBdYdY/maxresdefault.jpg"
-CercaThumbnail = "http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search"
-CercaFanart = "https://i.ytimg.com/vi/IAlbvyBdYdY/maxresdefault.jpg"
-AvantiTxt = config.get_localized_string(30992)
-AvantiImg = "http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"
+    return support.server(item, itemlist=itemlist)

channels/animeleggendari.json

@@ -1,62 +0,0 @@
-{
-    "id": "animeleggendari",
-    "name": "AnimePerTutti",
-    "active": true,
-    "adult": false,
-    "language": ["ita"],
-    "thumbnail": "animepertutti.png",
-    "bannermenu": "animepertutti.png",
-    "categories": ["anime"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-        {
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "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": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare", "IT"]
-        }
-    ]
-}

channels/animeleggendari.py

@@ -1,185 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per animeleggendari
-# ------------------------------------------------------------
-
-import re
-
-from core import servertools, httptools, scrapertoolsV2, tmdb, support
-from core.item import Item
-from core.support import log, menu
-from lib.js2py.host import jsfunctions
-from platformcode import logger, config
-from specials import autoplay, autorenumber
-
-__channel__ = "animeleggendari"
-host = config.get_channel_url(__channel__)
-
-# Richiesto per Autoplay
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream', 'openload', 'streamango']
-list_quality = ['default']
-
-checklinks = config.get_setting('checklinks', 'animeleggendari')
-checklinks_number = config.get_setting('checklinks_number', 'animeleggendari')
-
-def mainlist(item):
-    log()
-
-    itemlist = []
-    menu(itemlist, 'Anime Leggendari', 'peliculas', host + '/category/anime-leggendari/')
-    menu(itemlist, 'Anime ITA', 'peliculas', host + '/category/anime-ita/')
-    menu(itemlist, 'Anime SUB-ITA', 'peliculas', host + '/category/anime-sub-ita/')
-    menu(itemlist, 'Anime Conclusi', 'peliculas', host + '/category/serie-anime-concluse/')
-    menu(itemlist, 'Anime in Corso', 'peliculas', host + '/category/anime-in-corso/')
-    menu(itemlist, 'Genere', 'genres', host)
-    menu(itemlist, 'Cerca...', 'search')
-                     
-    autoplay.init(item.channel, list_servers, list_quality)
-    autoplay.show_option(item.channel, itemlist)
-
-    return itemlist
-
-def search(item, texto):
-    log(texto)
-    
-    item.url = host + "/?s=" + texto
-    try:
-        return peliculas(item)
-        
-    # Continua la ricerca in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-def last_ep(item):
-    log('ANIME PER TUTTI')
-    return support.scrape(item, '<a href="([^"]+)">([^<]+)<', ['url','title'],patron_block='<ul class="mh-tab-content-posts">(.*?)<\/ul>', action='findvideos')
-
-def newest(categoria):
-    log('ANIME PER TUTTI')
-    log(categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "anime":
-            item.url = host
-            item.action = "last_ep"
-            itemlist = last_ep(item)
-
-            if itemlist[-1].action == "last_ep":
-                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 genres(item):
-    itemlist = support.scrape(item, '<a href="([^"]+)">([^<]+)<', ['url', 'title'], action='peliculas', patron_block=r'Generi.*?<ul.*?>(.*?)<\/ul>', blacklist=['Contattaci','Privacy Policy', 'DMCA'])
-    return support.thumb(itemlist)
-
-def peliculas(item):    
-    log()
-    itemlist = []
-
-    blacklist = ['top 10 anime da vedere']
-    matches, data = support.match(item, r'<a class="[^"]+" href="([^"]+)" title="([^"]+)"><img[^s]+src="([^"]+)"[^>]+')
-
-    for url, title, thumb in matches:
-        title = scrapertoolsV2.decodeHtmlentities(title.strip()).replace("streaming", "")        
-        lang = scrapertoolsV2.find_single_match(title, r"((?:SUB ITA|ITA))")
-        videoType = '' 
-        if 'movie' in title.lower():
-            videoType = ' - (MOVIE)' 
-        if 'ova' in title.lower():
-            videoType = ' - (OAV)'
-
-        cleantitle = title.replace(lang, "").replace('(Streaming & Download)', '').replace('( Streaming & Download )', '').replace('OAV', '').replace('OVA', '').replace('MOVIE', '').strip()
-
-        if not videoType :
-            contentType="tvshow"
-            action="episodios"
-        else:
-            contentType="movie"
-            action="findvideos"
-
-        if not title.lower() in blacklist:
-            itemlist.append(
-                Item(channel=item.channel,
-                    action=action,
-                    contentType=contentType,
-                    title=support.typo(cleantitle + videoType, 'bold') + support.typo(lang,'_ [] color kod'),
-                    fulltitle=cleantitle,                    
-                    show=cleantitle,
-                    url=url,
-                    thumbnail=thumb))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    autorenumber.renumber(itemlist)    
-    support.nextPage(itemlist, item, data, r'<a class="next page-numbers" href="([^"]+)">')
-
-    return itemlist
-
-def episodios(item):
-    log()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    block = scrapertoolsV2.find_single_match(data, r'(?:<p style="text-align: left;">|<div class="pagination clearfix">\s*)(.*?)</span></a></div>')
-
-    itemlist.append(
-        Item(channel=item.channel,
-             action='findvideos',
-             contentType='episode',
-             title=support.typo('Episodio 1 bold'),
-             fulltitle=item.title,
-             url=item.url,
-             thumbnail=item.thumbnail))
-
-    if block:
-        matches = re.compile(r'<a href="([^"]+)".*?><span class="pagelink">(\d+)</span></a>', re.DOTALL).findall(data)
-        for url, number in matches:
-            itemlist.append(
-                Item(channel=item.channel,
-                     action='findvideos',
-                     contentType='episode',
-                     title=support.typo('Episodio ' + number,'bold'),
-                     fulltitle=item.title,
-                     url=url,
-                     thumbnail=item.thumbnail))
-    
-    autorenumber.renumber(itemlist, item)
-    support.videolibrary
-    return itemlist
-
-def findvideos(item):
-    log()
-    data = ''
-    matches = support.match(item, 'str="([^"]+)"')[0]
-    if matches:
-        for match in matches:
-            data += str(jsfunctions.unescape(re.sub('@|g','%', match)))
-            data += str(match)
-            log('DATA',data)
-            if 'animepertutti' in data:
-                log('ANIMEPERTUTTI!')
-          
-    else:
-        data = ''
-
-    itemlist = support.server(item,data)
-        
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # itemlist = filtertools.get_links(itemlist, item, list_language)
-    autoplay.start(itemlist, item)
-    
-    return itemlist

channels/animesaturn.json

@@ -2,69 +2,9 @@
     "id": "animesaturn",
     "name": "AnimeSaturn",
     "active": true,
-    "adult": false,
     "language": ["ita"],
     "thumbnail": "animesaturn.png",
     "banner": "animesaturn.png",
     "categories": ["anime"],
-    "settings": [
-        {
-            "id": "channel_host",
-            "type": "text",
-            "label": "Host del canale",
-            "default": "https://www.animesaturn.com",
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },    
-        {
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "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": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
+    "settings": []
 }

channels/animesaturn.py

@@ -1,379 +1,194 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
 # Canale per AnimeSaturn
-# Thanks to 4l3x87
 # ----------------------------------------------------------
-import re
 
-import urlparse
+from core import support
 
-import channelselector
-from core import httptools, tmdb, support, scrapertools, jsontools
-from core.item import Item
-from core.support import log
-from platformcode import logger, config
-from specials import autoplay, autorenumber
-
-__channel__ = "animesaturn"
-host = config.get_setting("channel_host", __channel__)
-headers = [['Referer', host]]
-
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['openload', 'fembed', 'animeworld']
-list_quality = ['default', '480p', '720p', '1080p']
+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):
-    log()
-    itemlist = []
-    support.menu(itemlist, 'Novità bold', 'ultimiep', "%s/fetch_pages.php?request=episodes" % host, 'tvshow')
-    support.menu(itemlist, 'Anime bold', 'lista_anime', "%s/animelist?load_all=1" % host)
-    support.menu(itemlist, 'Archivio A-Z submenu', 'list_az', '%s/animelist?load_all=1' % host, args=['tvshow', 'alfabetico'])
-    support.menu(itemlist, 'Cerca', 'search', host)
-    support.aplay(item, itemlist, list_servers, list_quality)
-    support.channel_config(item, itemlist)
 
-    return itemlist
+    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 cleantitle(scrapedtitle):
-    scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
-    scrapedtitle = scrapedtitle.replace('[HD]', '').replace('’', '\'').replace('×', 'x').replace('"', "'")
-    year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
-    if year:
-        scrapedtitle = scrapedtitle.replace('(' + year + ')', '')
-
-    return scrapedtitle.strip()
-
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def lista_anime(item):
-    log()
-    itemlist = []
-
-    PERPAGE = 15
-
-    p = 1
-    if '{}' in item.url:
-        item.url, p = item.url.split('{}')
-        p = int(p)
-
-    if '||' in item.url:
-        series = item.url.split('\n\n')
-        matches = []
-        for i, serie in enumerate(series):
-            matches.append(serie.split('||'))
-    else:
-        # Estrae i contenuti
-        patron = r'<a href="([^"]+)"[^>]*?>[^>]*?>(.+?)<'
-        matches = support.match(item, patron, headers=headers)[0]
-
-    scrapedplot = ""
-    scrapedthumbnail = ""
-    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
-        if (p - 1) * PERPAGE > i: continue
-        if i >= p * PERPAGE: break
-        title = cleantitle(scrapedtitle).replace('(ita)', '(ITA)')
-        movie = False
-        showtitle = title
-        if '(ITA)' in title:
-            title = title.replace('(ITA)', '').strip()
-            showtitle = title
-        else:
-            title += ' ' + support.typo('Sub-ITA', '_ [] color kod')
-
-        infoLabels = {}
-        if 'Akira' in title:
-            movie = True
-            infoLabels['year'] = 1988
-
-        if 'Dragon Ball Super Movie' in title:
-            movie = True
-            infoLabels['year'] = 2019
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 extra=item.extra,
-                 action="episodios" if movie == False else 'findvideos',
-                 title=title,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fulltitle=showtitle,
-                 show=showtitle,
-                 contentTitle=showtitle,
-                 plot=scrapedplot,
-                 contentType='episode' if movie == False else 'movie',
-                 originalUrl=scrapedurl,
-                 infoLabels=infoLabels,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    autorenumber.renumber(itemlist)
-
-    # Paginazione
-    if len(matches) >= p * PERPAGE:
-        support.nextPage(itemlist, item, next_page=(item.url + '{}' + str(p + 1)))
-
-    return itemlist
-
-
-# ================================================================================================================
-
-
-# ----------------------------------------------------------------------------------------------------------------
-def episodios(item):
-    log()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data
-    anime_id = scrapertools.find_single_match(data, r'\?anime_id=(\d+)')
-    # movie or series
-    movie = scrapertools.find_single_match(data, r'\Episodi:</b>\s(\d*)\sMovie')
-
-    data = httptools.downloadpage(
-        host + "/loading_anime?anime_id=" + anime_id,
-        headers={
-            'X-Requested-With': 'XMLHttpRequest'
-        }).data
-
-    patron = r'<td style="[^"]+"><b><strong" style="[^"]+">(.+?)</b></strong></td>\s*'
-    patron += r'<td style="[^"]+"><a href="([^"]+)"'
-    matches = scrapertools.find_multiple_matches(data, patron)
-
-    for scrapedtitle, scrapedurl in matches:
-        scrapedtitle = cleantitle(scrapedtitle)
-        scrapedtitle = re.sub(r'<[^>]*?>', '', scrapedtitle)
-        scrapedtitle = '[B]' + scrapedtitle + '[/B]'
-
-        itemlist.append(
-            Item(
-                channel=item.channel,
-                action="findvideos",
-                contentType="episode",
-                title=scrapedtitle,
-                url=urlparse.urljoin(host, scrapedurl),
-                fulltitle=scrapedtitle,
-                show=scrapedtitle,
-                plot=item.plot,
-                fanart=item.thumbnail,
-                thumbnail=item.thumbnail))
-
-    if ((len(itemlist) == 1 and 'Movie' in itemlist[0].title) or movie) and item.contentType != 'movie':
-        item.url = itemlist[0].url
-        item.contentType = 'movie'
-        return findvideos(item)
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    autorenumber.renumber(itemlist, item)
-    support.videolibrary(itemlist, item, 'bold color kod')
-
-    return itemlist
-
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def findvideos(item):
-    log()
-    originalItem = item
-
-    if item.contentType == 'movie':
-        episodes = episodios(item)
-        if len(episodes) > 0:
-            item.url = episodes[0].url
-
-    itemlist = []
-    data = httptools.downloadpage(item.url, headers=headers, ignore_response_code=True).data
-    data = re.sub(r'\n|\t|\s+', ' ', data)
-    patron = r'<a href="([^"]+)"><div class="downloadestreaming">'
-    url = scrapertools.find_single_match(data, patron)
-    data = httptools.downloadpage(url, headers=headers, ignore_response_code=True).data
-    data = re.sub(r'\n|\t|\s+', ' ', data)
-    itemlist = support.server(item, data=data)
-
-    return itemlist
-
-
-# ================================================================================================================
-
-
-# ----------------------------------------------------------------------------------------------------------------
-
-def ultimiep(item):
-    log()
-    itemlist = []
-
-    p = 1
-    if '{}' in item.url:
-        item.url, p = item.url.split('{}')
-        p = int(p)
-
-    post = "page=%s" % p if p > 1 else None
-
-    data = httptools.downloadpage(
-        item.url, post=post, headers={
-            'X-Requested-With': 'XMLHttpRequest'
-        }).data
-
-    patron = r"""<a href='[^']+'><div class="locandina"><img alt="[^"]+" src="([^"]+)" title="[^"]+" class="grandezza"></div></a>\s*"""
-    patron += r"""<a href='([^']+)'><div class="testo">(.+?)</div></a>\s*"""
-    patron += r"""<a href='[^']+'><div class="testo2">(.+?)</div></a>"""
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedthumbnail, scrapedurl, scrapedtitle1, scrapedtitle2 in matches:
-        scrapedtitle1 = cleantitle(scrapedtitle1)
-        scrapedtitle2 = cleantitle(scrapedtitle2)
-        scrapedtitle = scrapedtitle1 + ' - ' + scrapedtitle2 + ''
-
-        title = scrapedtitle
-        showtitle = scrapedtitle
-        if '(ITA)' in title:
-            title = title.replace('(ITA)', '').strip()
-            showtitle = title
-        else:
-            title += ' ' + support.typo('Sub-ITA', '_ [] color kod')
-
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 contentType="episode",
-                 action="findvideos",
-                 title=title,
-                 url=scrapedurl,
-                 fulltitle=scrapedtitle1,
-                 show=showtitle,
-                 thumbnail=scrapedthumbnail))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Pagine
-    patronvideos = r'data-page="(\d+)" title="Next">Pagina Successiva'
-    next_page = scrapertools.find_single_match(data, patronvideos)
-    if next_page:
-        support.nextPage(itemlist, item, next_page=(item.url + '{}' + next_page))
-
-    return itemlist
-
-
-# ================================================================================================================
-
-
-# ----------------------------------------------------------------------------------------------------------------
-def newest(categoria):
-    log(categoria)
-    itemlist = []
-    item = Item()
-    item.url = host
-    item.extra = ''
+def search(item, texto):
+    support.info(texto)
+    item.url = host + '/animelist?search=' + texto
+    item.contentType = 'tvshow'
     try:
-        if categoria == "anime":
-            item.url = "%s/fetch_pages?request=episodios" % host
-            item.action = "ultimiep"
-            itemlist = ultimiep(item)
-
-            if itemlist[-1].action == "ultimiep":
-                itemlist.pop()
-
+        return peliculas(item)
     # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
-            logger.error("{0}".format(line))
+            support.logger.error("%s" % line)
         return []
 
-    return itemlist
 
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def search_anime(item, texto):
-    log(texto)
+def newest(categoria):
+    support.info()
     itemlist = []
-
-    data = httptools.downloadpage(host + "/index.php?search=1&key=%s" % texto).data
-    jsondata = jsontools.load(data)
-
-    for title in jsondata:
-        data = str(httptools.downloadpage("%s/templates/header?check=1" % host, post="typeahead=%s" % title).data)
-
-        if 'Anime non esistente' in data:
-            continue
-        else:
-            title = title.replace('(ita)', '(ITA)')
-            showtitle = title
-            if '(ITA)' in title:
-                title = title.replace('(ITA)', '').strip()
-                showtitle = title
-            else:
-                title += ' ' + support.typo('Sub-ITA', '_ [] color kod')
-
-            url = "%s/anime/%s" % (host, data)
-
-            itemlist.append(
-                Item(
-                    channel=item.channel,
-                    contentType="episode",
-                    action="episodios",
-                    title=title,
-                    url=url,
-                    fulltitle=title,
-                    show=showtitle,
-                    thumbnail=""))
-
-    return itemlist
-
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def search(item, texto):
-    log(texto)
-    itemlist = []
-
+    item = support.Item()
     try:
-        return search_anime(item, texto)
-
+        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():
-            logger.error("%s" % line)
+            support.logger.error("{0}".format(line))
         return []
 
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-
-
-def list_az(item):
-    log()
-    itemlist = []
-
-    alphabet = dict()
-
-    # Articoli
-    patron = r'<a href="([^"]+)"[^>]*?>[^>]*?>(.+?)<'
-    matches = support.match(item, patron, headers=headers)[0]
-
-    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
-        letter = scrapedtitle[0].upper()
-        if letter not in alphabet:
-            alphabet[letter] = []
-        alphabet[letter].append(scrapedurl + '||' + scrapedtitle)
-
-    for letter in sorted(alphabet):
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista_anime",
-                 url='\n\n'.join(alphabet[letter]),
-                 title=letter,
-                 fulltitle=letter))
-
     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/animespace.json

@@ -1,52 +0,0 @@
-{
-  "id": "animespace",
-  "name": "AnimeSpace",
-  "active": true,
-  "adult": false,
-  "language": [],
-  "thumbnail": "",
-  "banner": "",
-  "categories": [
-    "anime",
-    "vos"
-  ],
-  "settings": [
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Incluir en busqueda global",
-      "default": false,
-      "enabled": false,
-      "visible": false
-    },
-    {
-      "id": "filter_languages",
-      "type": "list",
-      "label": "Mostrar enlaces en idioma...",
-      "default": 0,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "No filtrar",
-        "VOSE"
-      ]
-    },
-    {
-      "id": "checklinks_number",
-      "type": "list",
-      "label": "Número de enlaces a verificar",
-      "default": 1,
-      "enabled": true,
-      "visible": "eq(-1,true)",
-      "lvalues": [ "5", "10", "15", "20" ]
-    },
-    {
-      "id": "include_in_newest_anime",
-      "type": "bool",
-      "label": "Incluir en Novedades - Episodios de anime",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    }
-  ]
-}

channels/animespace.py

@@ -1,263 +0,0 @@
-# -*- coding: utf-8 -*-
-# -*- Channel AnimeSpace -*-
-# -*- Created for Alfa-addon -*-
-# -*- By the Alfa Develop Group -*-
-
-import re
-
-from channelselector import get_thumb
-from core import httptools
-from core import scrapertools
-from core import servertools
-from core import tmdb
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
-from specials import renumbertools
-
-__channel__ = "animespace"
-host = config.get_channel_url(__channel__)
-
-checklinks = config.get_setting('checklinks', 'animespace')
-checklinks_number = config.get_setting('checklinks_number', 'animespace')
-
-IDIOMAS = {'VOSE': 'VOSE'}
-list_language = IDIOMAS.values()
-list_quality = []
-list_servers = ['directo', 'openload', 'streamango']
-
-
-def mainlist(item):
-    logger.info()
-
-    autoplay.init(item.channel, list_servers, list_quality)
-
-    itemlist = []
-
-    itemlist.append(Item(channel=item.channel, title="Nuevos Episodios",
-                         action="new_episodes",
-                         thumbnail=get_thumb('new_episodes', auto=True),
-                         url=host))
-
-    itemlist.append(Item(channel=item.channel, title="Ultimas",
-                               action="list_all",
-                               thumbnail=get_thumb('last', auto=True),
-                               url=host + '/emision'))
-
-    itemlist.append(Item(channel=item.channel, title="Todas",
-                               action="list_all",
-                               thumbnail=get_thumb('all', auto=True),
-                               url=host + '/animes'))
-
-    itemlist.append(Item(channel=item.channel, title="Anime",
-                              action="list_all",
-                              thumbnail=get_thumb('anime', auto=True),
-                              url=host + '/categoria/anime'))
-
-    itemlist.append(Item(channel=item.channel, title="Películas",
-                         action="list_all",
-                         thumbnail=get_thumb('movies', auto=True),
-                         url=host + '/categoria/pelicula'))
-
-    itemlist.append(Item(channel=item.channel, title="OVAs",
-                              action="list_all",
-                              thumbnail='',
-                              url=host + '/categoria/ova'))
-
-    itemlist.append(Item(channel=item.channel, title="ONAs",
-                              action="list_all",
-                              thumbnail='',
-                              url=host + '/categoria/ona'))
-
-
-    itemlist.append(Item(channel=item.channel, title="Especiales",
-                              action="list_all",
-                              thumbnail='',
-                              url=host + '/categoria/especial'))
-
-    itemlist.append(Item(channel=item.channel, title="Buscar",
-                               action="search",
-                               url=host + '/search?q=',
-                               thumbnail=get_thumb('search', auto=True),
-                               fanart='https://s30.postimg.cc/pei7txpa9/buscar.png'
-                               ))
-
-    autoplay.show_option(item.channel, itemlist)
-    itemlist = renumbertools.show_option(item.channel, itemlist)
-
-    return itemlist
-
-
-def get_source(url):
-    logger.info()
-    data = httptools.downloadpage(url).data
-    data = re.sub(r'\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
-    return data
-
-
-def list_all(item):
-    logger.info()
-
-    itemlist = []
-
-    data = get_source(item.url)
-    patron = '<article.*?href="([^"]+)">.*?src="([^"]+)".*?'
-    patron +=  '<h3 class="Title">([^<]+)</h3>.*?"fecha">([^<]+)<.*?</i>([^<]+)'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, scrapedtitle, year, type in matches:
-        type = type.strip().lower()
-        url = scrapedurl
-        thumbnail = scrapedthumbnail
-        lang = 'VOSE'
-        title = scrapedtitle
-        context = renumbertools.context(item)
-        context2 = autoplay.context
-        context.extend(context2)
-        new_item= Item(channel=item.channel,
-                       action='episodios',
-                       title=title,
-                       url=url,
-                       thumbnail=thumbnail,
-                       language = lang,
-                       infoLabels={'year':year}
-                       )
-        if type != 'anime':
-            new_item.contentTitle=title
-        else:
-            new_item.plot=type
-            new_item.contentSerieName=title
-            new_item.context = context
-        itemlist.append(new_item)
-
-        # Paginacion
-    next_page = scrapertools.find_single_match(data,
-                                               '"page-item active">.*?</a>.*?<a class="page-link" href="([^"]+)">')
-
-    if next_page != "":
-        actual_page = scrapertools.find_single_match(item.url, '([^\?]+)?')
-        itemlist.append(Item(channel=item.channel,
-                             action="list_all",
-                             title=">> Página siguiente",
-                             url=actual_page + next_page,
-                             thumbnail='https://s16.postimg.cc/9okdu7hhx/siguiente.png'
-                             ))
-    tmdb.set_infoLabels(itemlist, seekTmdb=True)
-    return itemlist
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = item.url + texto
-    try:
-        if texto != '':
-            return list_all(item)
-        else:
-            return []
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-def new_episodes(item):
-    logger.info()
-
-    itemlist = []
-
-    full_data = get_source(item.url)
-    data = scrapertools.find_single_match(full_data, '<section class="caps">.*?</section>')
-    patron = '<article.*?<a href="([^"]+)">.*?src="([^"]+)".*?'
-    patron += '<span class="episode">.*?</i>([^<]+)</span>.*?<h2 class="Title">([^<]+)</h2>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, epi, scrapedtitle in matches:
-        url = scrapedurl
-        lang = 'VOSE'
-        title = '%s - %s' % (scrapedtitle, epi)
-        itemlist.append(Item(channel=item.channel, title=title, url=url, thumbnail=scrapedthumbnail,
-                             action='findvideos', language=lang))
-
-    return itemlist
-
-def episodios(item):
-    logger.info()
-    itemlist = []
-
-    data = get_source(item.url)
-    patron = '<a class="item" href="([^"]+)">'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    infoLabels = item.infoLabels
-    for scrapedurl in matches:
-        episode = scrapertools.find_single_match(scrapedurl, '.*?capitulo-(\d+)')
-        lang = 'VOSE'
-        season, episode = renumbertools.numbered_for_tratk(item.channel, item.contentSerieName, 1, int(episode))
-        title = "%sx%s - %s" % (season, str(episode).zfill(2),item.contentSerieName)
-        url = scrapedurl
-        infoLabels['season'] = season
-        infoLabels['episode'] = episode
-
-        itemlist.append(Item(channel=item.channel, title=title, contentSerieName=item.contentSerieName, url=url,
-                             action='findvideos', language=lang, infoLabels=infoLabels))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    itemlist = itemlist[::-1]
-    if item.contentSerieName != '' and config.get_videolibrary_support() and len(itemlist) > 0:
-        itemlist.append(
-            Item(channel=item.channel, title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]', url=item.url,
-                 action="add_serie_to_library", extra="episodios", contentSerieName=item.contentSerieName,
-                 extra1='library'))
-
-    return itemlist
-
-
-def findvideos(item):
-    import urllib
-    logger.info()
-
-    itemlist = []
-
-    data = get_source(item.url)
-    patron = 'id="Opt\d+">.*?src=(.*?) frameborder'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl in matches:
-        server = ''
-        scrapedurl = scrapedurl.replace('&quot;', '')
-        new_data = get_source(scrapedurl)
-
-        if "/stream/" in scrapedurl:
-            scrapedurl = scrapertools.find_single_match(new_data, '<source src="([^"]+)"')
-            server = "directo"
-        else:
-            scrapedurl = scrapertools.find_single_match(scrapedurl, '.*?url=([^&]+)?')
-            scrapedurl = urllib.unquote(scrapedurl)
-
-        if scrapedurl != '':
-            itemlist.append(Item(channel=item.channel, title='%s', url=scrapedurl, action='play',
-                                 language = item.language, infoLabels=item.infoLabels, server=server))
-
-    itemlist = servertools.get_servers_itemlist(itemlist, lambda x: x.title % x.server.capitalize())
-
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # Requerido para FilterTools
-
-    # itemlist = filtertools.get_links(itemlist, item, list_language)
-
-    # Requerido para AutoPlay
-
-    autoplay.start(itemlist, item)
-
-    return itemlist
-
-def newest(categoria):
-    itemlist = []
-    item = Item()
-    if categoria == 'anime':
-        item.url=host
-        itemlist = new_episodes(item)
-    return itemlist

channels/animesubita.json

@@ -1,37 +0,0 @@
-{
-    "id": "animesubita",
-    "name": "AnimeSubIta",
-    "active": true,
-    "adult": false,
-    "language": ["ita"],
-    "thumbnail": "animesubita.png",
-    "bannermenu": "animesubita.png",
-    "categories": ["anime"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        }
-    ]
-}
-

channels/animesubita.py

@@ -1,343 +0,0 @@
-# -*- coding: utf-8 -*-
-# Ringraziamo Icarus crew
-# ------------------------------------------------------------
-# Ringraziamo Icarus crew
-# Canale per AnimeSubIta
-# ------------------------------------------------------------
-
-import re
-import urllib
-import urlparse
-
-from core import httptools, scrapertools, tmdb, support
-from core.item import Item
-from platformcode import logger, config
-
-__channel__ = "animesubita"
-host = config.get_channel_url(__channel__)
-PERPAGE = 20
-
-# ----------------------------------------------------------------------------------------------------------------
-def mainlist(item):
-    logger.info()
-    itemlist = [Item(channel=item.channel,
-                     action="lista_anime_completa",
-                     title=support.color("Lista Anime", "azure"),
-                     url="%s/lista-anime/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     action="ultimiep",
-                     title=support.color("Ultimi Episodi", "azure"),
-                     url="%s/category/ultimi-episodi/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     action="lista_anime",
-                     title=support.color("Anime in corso", "azure"),
-                     url="%s/category/anime-in-corso/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     action="categorie",
-                     title=support.color("Categorie", "azure"),
-                     url="%s/generi/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     action="search",
-                     title=support.color("Cerca anime ...", "yellow"),
-                     extra="anime",
-                     thumbnail="http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")
-                ]
-
-    return itemlist
-
-# ================================================================================================================
-# ----------------------------------------------------------------------------------------------------------------
-def newest(categoria):
-    logger.info()
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "anime":
-            item.url = host
-            item.action = "ultimiep"
-            itemlist = ultimiep(item)
-
-            if itemlist[-1].action == "ultimiep":
-                itemlist.pop()
-    # Continua l'esecuzione in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("{0}".format(line))
-        return []
-
-    return itemlist
-
-# ================================================================================================================
-# ----------------------------------------------------------------------------------------------------------------
-def search(item, texto):
-    logger.info()
-    item.url = host + "/?s=" + texto
-    try:
-        return lista_anime(item)
-    # Continua la ricerca in caso di errore 
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def categorie(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    patron = r'<li><a title="[^"]+" href="([^"]+)">([^<]+)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(
-                Item(channel=item.channel,
-                     action="lista_anime",
-                     title=scrapedtitle.replace('Anime', '').strip(),
-                     text_color="azure",
-                     url=scrapedurl,
-                     thumbnail=item.thumbnail,
-                     folder=True))
-
-    return itemlist
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def ultimiep(item):
-    logger.info("ultimiep")
-    itemlist = lista_anime(item, False, False)
-
-    for itm in itemlist:
-        title = scrapertools.decodeHtmlentities(itm.title)
-        # Pulizia titolo
-        title = title.replace("Streaming", "").replace("&", "")
-        title = title.replace("Download", "")
-        title = title.replace("Sub Ita", "").strip()
-        eptype = scrapertools.find_single_match(title, "((?:Episodio?|OAV))")
-        cleantitle = re.sub(r'%s\s*\d*\s*(?:\(\d+\)|)' % eptype, '', title).strip()
-        # Creazione URL
-        url = re.sub(r'%s-?\d*-' % eptype.lower(), '', itm.url)
-        if "-streaming" not in url:
-            url = url.replace("sub-ita", "sub-ita-streaming")
-
-        epnumber = ""
-        if 'episodio' in eptype.lower():
-            epnumber = scrapertools.find_single_match(title.lower(), r'episodio?\s*(\d+)')
-            eptype += ":? " + epnumber
-                
-        extra = "<tr>\s*<td[^>]+><strong>(?:[^>]+>|)%s(?:[^>]+>[^>]+>|[^<]*|[^>]+>)</strong>" % eptype
-        itm.title = support.color(title, 'azure').strip()
-        itm.action = "findvideos"
-        itm.url = url
-        itm.fulltitle = cleantitle
-        itm.extra = extra
-        itm.show = re.sub(r'Episodio\s*', '', title)
-        itm.thumbnail = item.thumbnail
-    
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    return itemlist
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def lista_anime(item, nextpage=True, show_lang=True):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    blocco = scrapertools.find_single_match(data, r'<div class="post-list group">(.*?)</nav><!--/.pagination-->')
-    # patron = r'<a href="([^"]+)" title="([^"]+)">\s*<img[^s]+src="([^"]+)"[^>]+>' # Patron con thumbnail, Kodi non scarica le immagini dal sito
-    patron = r'<a href="([^"]+)" title="([^"]+)">'
-    matches = re.compile(patron, re.DOTALL).findall(blocco)
-
-    for scrapedurl, scrapedtitle in matches:
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        scrapedtitle = re.sub(r'\s+', ' ', scrapedtitle)
-        # Pulizia titolo
-        scrapedtitle = scrapedtitle.replace("Streaming", "").replace("&", "")
-        scrapedtitle = scrapedtitle.replace("Download", "")
-        lang = scrapertools.find_single_match(scrapedtitle, r"([Ss][Uu][Bb]\s*[Ii][Tt][Aa])")
-        scrapedtitle = scrapedtitle.replace("Sub Ita", "").strip()
-        eptype = scrapertools.find_single_match(scrapedtitle, "((?:Episodio?|OAV))")
-        cleantitle = re.sub(r'%s\s*\d*\s*(?:\(\d+\)|)' % eptype, '', scrapedtitle)
-
-
-        cleantitle = cleantitle.replace(lang, "").strip()
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="episodi",
-                 contentType="tvshow" if 'oav' not in scrapedtitle.lower() else "movie",
-                 title=color(scrapedtitle.replace(lang, "(%s)" % support.color(lang, "red") if show_lang else "").strip(), 'azure'),
-                 fulltitle=cleantitle,
-                 url=scrapedurl,
-                 show=cleantitle,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    if nextpage:
-        patronvideos = r'<link rel="next" href="([^"]+)"\s*/>'
-        matches = re.compile(patronvideos, re.DOTALL).findall(data)
-        
-        if len(matches) > 0:
-            scrapedurl = matches[0]
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="lista_anime",
-                    title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                    url=scrapedurl,
-                    thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
-                    folder=True))
-
-    return itemlist
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def lista_anime_completa(item):
-    logger.info()
-    itemlist = []
-
-    p = 1
-    if '{}' in item.url:
-        item.url, p = item.url.split('{}')
-        p = int(p)
-
-    data = httptools.downloadpage(item.url).data
-    blocco = scrapertools.find_single_match(data, r'<ul class="lcp_catlist"[^>]+>(.*?)</ul>')
-    patron = r'<a href="([^"]+)"[^>]+>([^<]+)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(blocco)
-
-    for i, (scrapedurl, scrapedtitle) in enumerate(matches):
-        if (p - 1) * PERPAGE > i: continue
-        if i >= p * PERPAGE: break
-
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle.strip())
-        cleantitle = scrapedtitle.replace("Sub Ita Streaming", "").replace("Ita Streaming", "")
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="episodi",
-                 contentType="tvshow" if 'oav' not in scrapedtitle.lower() else "movie",
-                 title=support.color(scrapedtitle, 'azure'),
-                 fulltitle=cleantitle,
-                 show=cleantitle,
-                 url=scrapedurl,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    if len(matches) >= p * PERPAGE:
-        scrapedurl = item.url + '{}' + str(p + 1)
-        itemlist.append(
-            Item(channel=item.channel,
-                 extra=item.extra,
-                 action="lista_anime_completa",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
-                 folder=True))
-
-    return itemlist
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def episodi(item):
-    logger.info()
-    itemlist = []
-    
-    data = httptools.downloadpage(item.url).data
-
-    patron = '<td style="[^"]*?">\s*.*?<strong>(.*?)</strong>.*?\s*</td>\s*<td style="[^"]*?">\s*<a href="([^"]+?)"[^>]+>\s*<img.*?src="([^"]+?)".*?/>\s*</a>\s*</td>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedtitle, scrapedurl, scrapedimg in matches:
-        if 'nodownload' in scrapedimg or 'nostreaming' in scrapedimg:
-            continue
-        if 'vvvvid' in scrapedurl.lower():
-            itemlist.append(Item(title='I Video VVVVID Non sono supportati'))
-            continue
-
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        scrapedtitle = re.sub(r'<[^>]*?>', '', scrapedtitle)
-        scrapedtitle = '[COLOR azure][B]' + scrapedtitle + '[/B][/COLOR]'
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="episode",
-                 title=scrapedtitle,
-                 url=urlparse.urljoin(host, scrapedurl),
-                 fulltitle=item.title,
-                 show=scrapedtitle,
-                 plot=item.plot,
-                 fanart=item.thumbnail,
-                 thumbnail=item.thumbnail))
-
-    # Comandi di servizio
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
-
-    return itemlist
-
-# ================================================================================================================
-
-# ----------------------------------------------------------------------------------------------------------------
-def findvideos(item):
-    logger.info()
-    itemlist = []
-
-    headers = {'Upgrade-Insecure-Requests': '1',
-                'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; rv:52.0) Gecko/20100101 Firefox/52.0'}
-
-    if item.extra:
-        data = httptools.downloadpage(item.url, headers=headers).data
-        blocco = scrapertools.find_single_match(data, r'%s(.*?)</tr>' % item.extra)
-        item.url = scrapertools.find_single_match(blocco, r'<a href="([^"]+)"[^>]+>')
-
-    patron = r'http:\/\/link[^a]+animesubita[^o]+org\/[^\/]+\/.*?(episodio\d*)[^p]+php(\?.*)'
-    for phpfile, scrapedurl in re.findall(patron, item.url, re.DOTALL):
-        url = "%s/%s.php%s" % (host, phpfile, scrapedurl)
-        headers['Referer'] =  url
-        data = httptools.downloadpage(url, headers=headers).data
-        # ------------------------------------------------
-        cookies = ""
-        matches = re.compile('(.%s.*?)\n' % host.replace("http://", "").replace("www.", ""), re.DOTALL).findall(config.get_cookie_data())
-        for cookie in matches:
-            name = cookie.split('\t')[5]
-            value = cookie.split('\t')[6]
-            cookies += name + "=" + value + ";"
-        headers['Cookie'] = cookies[:-1]
-        # ------------------------------------------------
-        scrapedurl = scrapertools.find_single_match(data, r'<source src="([^"]+)"[^>]+>')
-        url = scrapedurl + '|' + urllib.urlencode(headers)
-        itemlist.append(
-            Item(channel=item.channel,
-                action="play",
-                text_color="azure",
-                title="[%s] %s" % (support.color("Diretto", "orange"), item.title),
-                fulltitle=item.fulltitle,
-                url=url,
-                thumbnail=item.thumbnail,
-                fanart=item.thumbnail,
-                plot=item.plot))
-
-    return itemlist

channels/animetubeita.json

@@ -1,36 +0,0 @@
-{
-    "id": "animetubeita",
-    "name": "Animetubeita",
-    "active": true,
-    "adult": false,
-    "language": ["ita"],
-    "thumbnail": "http:\/\/i.imgur.com\/rQPx1iQ.png",
-    "bannermenu": "http:\/\/i.imgur.com\/rQPx1iQ.png",
-    "categories": ["anime"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-        {
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        }
-    ]
-}

channels/animetubeita.py

@@ -1,364 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Ringraziamo Icarus crew
-# Canale per animetubeita
-# ----------------------------------------------------------
-import re
-import urllib
-
-from core import httptools, scrapertools, tmdb
-from core.item import Item
-from platformcode import logger, config
-
-__channel__ = "animetubeita"
-host = config.get_channel_url(__channel__)
-hostlista = host + "/lista-anime/"
-hostgeneri = host + "/generi/"
-hostcorso = host + "/category/serie-in-corso/"
-
-
-def mainlist(item):
-    log("animetubeita", "mainlist", item.channel)
-    itemlist = [Item(channel=item.channel,
-                     action="lista_home",
-                     title="[COLOR azure]Home[/COLOR]",
-                     url=host,
-                     thumbnail=AnimeThumbnail,
-                     fanart=AnimeFanart),
-                # Item(channel=item.channel,
-                #      action="lista_anime",
-                #      title="[COLOR azure]A-Z[/COLOR]",
-                #      url=hostlista,
-                #      thumbnail=AnimeThumbnail,
-                #      fanart=AnimeFanart),
-                Item(channel=item.channel,
-                     action="lista_genere",
-                     title="[COLOR azure]Genere[/COLOR]",
-                     url=hostgeneri,
-                     thumbnail=CategoriaThumbnail,
-                     fanart=CategoriaFanart),
-                Item(channel=item.channel,
-                     action="lista_in_corso",
-                     title="[COLOR azure]Serie in Corso[/COLOR]",
-                     url=hostcorso,
-                     thumbnail=CategoriaThumbnail,
-                     fanart=CategoriaFanart),
-                Item(channel=item.channel,
-                     action="search",
-                     title="[COLOR lime]Cerca...[/COLOR]",
-                     url=host + "/?s=",
-                     thumbnail=CercaThumbnail,
-                     fanart=CercaFanart)]
-    return itemlist
-
-
-
-def lista_home(item):
-    log("animetubeita", "lista_home", item.channel)
-
-    itemlist = []
-
-    patron = '<h2 class="title"><a href="(.*?)" rel="bookmark" title=".*?">.*?<img.*?src="(.*?)".*?<strong>Titolo</strong></td>.*?<td>(.*?)</td>.*?<td><strong>Trama</strong></td>.*?<td>(.*?)</'
-    for scrapedurl, scrapedthumbnail, scrapedtitle, scrapedplot in scrapedAll(item.url, patron):
-        title = scrapertools.decodeHtmlentities(scrapedtitle)
-        title = title.split("Sub")[0]
-        fulltitle = re.sub(r'[Ee]pisodio? \d+', '', title)
-        scrapedplot = scrapertools.decodeHtmlentities(scrapedplot)
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="dl_s",
-                 contentType="tvshow",
-                 title="[COLOR azure]" + title + "[/COLOR]",
-                 fulltitle=fulltitle,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fanart=scrapedthumbnail,
-                 show=fulltitle,
-                 plot=scrapedplot))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Paginazione
-    # ===========================================================
-    data = httptools.downloadpage(item.url).data
-    patron = '<link rel="next" href="(.*?)"'
-    next_page = scrapertools.find_single_match(data, patron)
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista_home",
-                 title=AvantiTxt,
-                 url=next_page,
-                 thumbnail=AvantiImg,
-                 folder=True))
-    # ===========================================================
-    return itemlist
-
-
-
-# def lista_anime(item):
-#     log("animetubeita", "lista_anime", item.channel)
-
-#     itemlist = []
-
-#     patron = '<li.*?class="page_.*?href="(.*?)">(.*?)</a></li>'
-#     for scrapedurl, scrapedtitle in scrapedAll(item.url, patron):
-#         title = scrapertools.decodeHtmlentities(scrapedtitle)
-#         title = title.split("Sub")[0]
-#         log("url:[" + scrapedurl + "] scrapedtitle:[" + title + "]")
-#         itemlist.append(
-#             Item(channel=item.channel,
-#                  action="dettaglio",
-#                  contentType="tvshow",
-#                  title="[COLOR azure]" + title + "[/COLOR]",
-#                  url=scrapedurl,
-#                  show=title,
-#                  thumbnail="",
-#                  fanart=""))
-
-#     tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-#     return itemlist
-
-
-
-def lista_genere(item):
-    log("lista_anime_genere", "lista_genere", item.channel)
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    bloque = scrapertools.find_single_match(data,
-                                    '<div class="hentry page post-1 odd author-admin clear-block">(.*?)<div id="disqus_thread">')
-
-    patron = '<li class="cat-item cat-item.*?"><a href="(.*?)" >(.*?)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(bloque)
-    scrapertools.printMatches(matches)
-
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista_generi",
-                 title='[COLOR lightsalmon][B]' + scrapedtitle + '[/B][/COLOR]',
-                 url=scrapedurl,
-                 fulltitle=scrapedtitle,
-                 show=scrapedtitle,
-                 thumbnail=item.thumbnail))
-
-    return itemlist
-
-
-
-def lista_generi(item):
-    log("animetubeita", "lista_generi", item.channel)
-
-    itemlist = []
-    patron = '<h2 class="title"><a href="(.*?)" rel="bookmark" title=".*?">.*?<img.*?src="(.*?)".*?<strong>Titolo</strong></td>.*?<td>(.*?)</td>.*?<td><strong>Trama</strong></td>.*?<td>(.*?)</'
-    for scrapedurl, scrapedthumbnail, scrapedtitle, scrapedplot in scrapedAll(item.url, patron):
-        title = scrapertools.decodeHtmlentities(scrapedtitle)
-        title = title.split("Sub")[0]
-        fulltitle = re.sub(r'[Ee]pisodio? \d+', '', title)
-        scrapedplot = scrapertools.decodeHtmlentities(scrapedplot)
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="dettaglio",
-                 title="[COLOR azure]" + title + "[/COLOR]",
-                 contentType="tvshow",
-                 fulltitle=fulltitle,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 show=fulltitle,
-                 fanart=scrapedthumbnail,
-                 plot=scrapedplot))
-                 
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Paginazione
-    # ===========================================================
-    data = httptools.downloadpage(item.url).data
-    patron = '<link rel="next" href="(.*?)"'
-    next_page = scrapertools.find_single_match(data, patron)
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista_generi",
-                 title=AvantiTxt,
-                 url=next_page,
-                 thumbnail=AvantiImg,
-                 folder=True))
-    # ===========================================================
-
-
-    return itemlist
-
-
-
-def lista_in_corso(item):
-    log("animetubeita", "lista_home", item.channel)
-
-    itemlist = []
-
-    patron = '<h2 class="title"><a href="(.*?)" rel="bookmark" title="Link.*?>(.*?)</a></h2>.*?<img.*?src="(.*?)".*?<td><strong>Trama</strong></td>.*?<td>(.*?)</td>'
-    for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedplot in scrapedAll(item.url, patron):
-        title = scrapertools.decodeHtmlentities(scrapedtitle)
-        title = title.split("Sub")[0]
-        fulltitle = re.sub(r'[Ee]pisodio? \d+', '', title)
-        scrapedplot = scrapertools.decodeHtmlentities(scrapedplot)
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="dettaglio",
-                 title="[COLOR azure]" + title + "[/COLOR]",
-                 contentType="tvshow",
-                 fulltitle=fulltitle,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 show=fulltitle,
-                 fanart=scrapedthumbnail,
-                 plot=scrapedplot))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    
-    # Paginazione
-    # ===========================================================
-    data = httptools.downloadpage(item.url).data
-    patron = '<link rel="next" href="(.*?)"'
-    next_page = scrapertools.find_single_match(data, patron)
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista_in_corso",
-                 title=AvantiTxt,
-                 url=next_page,
-                 thumbnail=AvantiImg,
-                 folder=True))
-    # ===========================================================
-    return itemlist
-
-
-
-def dl_s(item):
-    log("animetubeita", "dl_s", item.channel)
-
-    itemlist = []
-    encontrados = set()
-
-    # 1
-    patron = '<p><center><a.*?href="(.*?)"'
-    for scrapedurl in scrapedAll(item.url, patron):
-        if scrapedurl in encontrados: continue
-        encontrados.add(scrapedurl)
-        title = "DOWNLOAD & STREAMING"
-        itemlist.append(Item(channel=item.channel,
-                             action="dettaglio",
-                             title="[COLOR azure]" + title + "[/COLOR]",
-                             url=scrapedurl,
-                             thumbnail=item.thumbnail,
-                             fanart=item.thumbnail,
-                             plot=item.plot,
-                             folder=True))
-    # 2
-    patron = '<p><center>.*?<a.*?href="(.*?)"'
-    for scrapedurl in scrapedAll(item.url, patron):
-        if scrapedurl in encontrados: continue
-        encontrados.add(scrapedurl)
-        title = "DOWNLOAD & STREAMING"
-        itemlist.append(Item(channel=item.channel,
-                             action="dettaglio",
-                             title="[COLOR azure]" + title + "[/COLOR]",
-                             url=scrapedurl,
-                             thumbnail=item.thumbnail,
-                             fanart=item.thumbnail,
-                             plot=item.plot,
-                             folder=True))
-
-    return itemlist
-
-
-
-def dettaglio(item):
-    log("animetubeita", "dettaglio", item.channel)
-
-    itemlist = []
-    headers = {'Upgrade-Insecure-Requests': '1',
-               'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; rv:52.0) Gecko/20100101 Firefox/52.0'}
-
-    episodio = 1
-    patron = r'<a href="http:\/\/link[^a]+animetubeita[^c]+com\/[^\/]+\/[^s]+((?:stream|strm))[^p]+php(\?.*?)"'
-    for phpfile, scrapedurl in scrapedAll(item.url, patron):
-        title = "Episodio " + str(episodio)
-        episodio += 1
-        url = "%s/%s.php%s" % (host, phpfile, scrapedurl)
-        headers['Referer'] =  url
-        data = httptools.downloadpage(url, headers=headers).data
-        # ------------------------------------------------
-        cookies = ""
-        matches = re.compile('(.animetubeita.com.*?)\n', re.DOTALL).findall(config.get_cookie_data())
-        for cookie in matches:
-            name = cookie.split('\t')[5]
-            value = cookie.split('\t')[6]
-            cookies += name + "=" + value + ";"
-        headers['Cookie'] = cookies[:-1]
-        # ------------------------------------------------
-        url = scrapertools.find_single_match(data, """<source src="([^"]+)" type='video/mp4'>""")
-        url += '|' + urllib.urlencode(headers)
-        itemlist.append(Item(channel=item.channel,
-                             action="play",
-                             title="[COLOR azure]" + title + "[/COLOR]",
-                             url=url,
-                             thumbnail=item.thumbnail,
-                             fanart=item.thumbnail,
-                             plot=item.plot))
-
-    return itemlist
-
-
-
-def search(item, texto):
-    log("animetubeita", "search", item.channel)
-    item.url = item.url + texto
-
-    try:
-        return lista_home(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-
-def scrapedAll(url="", patron=""):
-    matches = []
-    data = httptools.downloadpage(url).data
-    MyPatron = patron
-    matches = re.compile(MyPatron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    return matches
-
-
-
-def scrapedSingle(url="", single="", patron=""):
-    matches = []
-    data = httptools.downloadpage(url).data
-    elemento = scrapertools.find_single_match(data, single)
-    matches = re.compile(patron, re.DOTALL).findall(elemento)
-    scrapertools.printMatches(matches)
-
-    return matches
-
-
-
-def log(funzione="", stringa="", canale=""):
-    logger.debug("[" + canale + "].[" + funzione + "] " + stringa)
-
-
-
-AnimeThumbnail = "http://img15.deviantart.net/f81c/i/2011/173/7/6/cursed_candies_anime_poster_by_careko-d3jnzg9.jpg"
-AnimeFanart = "http://www.animetubeita.com/wp-content/uploads/21407_anime_scenery.jpg"
-CategoriaThumbnail = "http://static.europosters.cz/image/750/poster/street-fighter-anime-i4817.jpg"
-CategoriaFanart = "http://www.animetubeita.com/wp-content/uploads/21407_anime_scenery.jpg"
-CercaThumbnail = "http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search"
-CercaFanart = "https://i.ytimg.com/vi/IAlbvyBdYdY/maxresdefault.jpg"
-AvantiTxt = config.get_localized_string(30992)
-AvantiImg = "http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"

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,268 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per AnimeUnity
+# ------------------------------------------------------------
+
+import cloudscraper, json, copy, inspect
+from core import jsontools, support, httptools, scrapertools
+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.data, 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
+    next_year = datetime.today().year + 1
+    oldest_year = int(support.match(response.data, patron='anime_oldest_date="([^"]+)').match)
+
+    for year in list(reversed(range(oldest_year, next_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 = []
+
+    fullJs = json.loads(support.match(httptools.downloadpage(item.url).data, headers=headers, patron=r'items-json="([^"]+)"').match.replace('"','"'))
+    js = fullJs['data']
+
+    for it in js:
+        if it.get('anime', {}).get('title') or it.get('anime', {}).get('title_eng'):
+            title_name = it['anime']['title'] if it.get('anime', {}).get('title') else it['anime']['title_eng']
+            pattern = r'[sS](?P<season>\d+)[eE](?P<episode>\d+)'
+            match = scrapertools.find_single_match(it['file_name'], pattern)
+            full_episode = ''
+            if match:
+                season, episode = match
+                full_episode = ' - S' + season + ' E' + episode
+            else:
+                pattern = r'[._\s]Ep[._\s]*(?P<episode>\d+)'
+                episode = scrapertools.find_single_match(it['file_name'], pattern)
+                if episode:
+                    full_episode = ' - E' + episode                             
+            itemlist.append(
+                item.clone(title = support.typo(title_name + full_episode, 'bold'),
+                           fulltitle = it['anime']['title'],
+                           thumbnail = it['anime']['imageurl'],
+                           forcethumb = True,
+                           scws_id = it.get('scws_id', ''),
+                           url = '{}/anime/{}-{}'.format(item.url, it['anime']['id'],it['anime']['slug']),
+                           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

@@ -1,70 +1,29 @@
 {
-    "id": "animeworld", 
-    "name": "AnimeWorld", 
-    "active": true, 
-    "adult": false, 
-    "language": ["ita"],
+    "id": "animeworld",
+    "name": "AnimeWorld",
+    "active": true,
+    "language": ["ita", "sub-ita"],
     "thumbnail": "animeworld.png",
     "banner": "animeworld.png",
-    "categories": ["anime"],
+    "categories": ["anime", "vos"],
     "settings": [
         {
-            "id": "channel_host",
-            "type": "text",
-            "label": "Host del canale",
-            "default": "https://www.animeworld.it",
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_global_search", 
-            "type": "bool", 
-            "label": "Includi ricerca globale", 
-            "default": false, 
-            "enabled": false, 
-            "visible": false
-        }, 
-        {
-            "id": "include_in_newest_anime", 
-            "type": "bool", 
-            "label": "Includi in Novità - Anime", 
-            "default": true, 
-            "enabled": true, 
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "checklinks",
-            "type": "bool",
-            "label": "Verifica se i link esistono",
-            "default": false,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "checklinks_number",
+            "id": "lang",
             "type": "list",
-            "label": "Numero de link da verificare",
-            "default": 1,
-            "enabled": true,
-            "visible": "eq(-1,true)",
-            "lvalues": [ "1", "3", "5", "10" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
+            "label": "Lingua di Ricerca",
             "default": 0,
             "enabled": true,
             "visible": true,
-            "lvalues": ["No filtrar","Italiano"]
-            }
+            "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

@@ -1,315 +1,196 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
 # Canale per animeworld
+# thanks to fatshotty
 # ----------------------------------------------------------
-import re
-import time
-import urllib
-import urlparse
 
-from core import httptools, scrapertoolsV2, servertools, tmdb, support, jsontools
-from core.support import log
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay, autorenumber
+from core import httptools, support, config, jsontools
 
-__channel__ = "animeworld"
-host = config.get_channel_url(__channel__)
-headers = [['Referer', host]]
-
-IDIOMAS = {'Italiano': 'Italiano'}
-list_language = IDIOMAS.values()
-list_servers = ['animeworld', 'verystream', 'streamango', 'openload', 'directo']
-list_quality = ['default', '480p', '720p', '1080p']
+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):
-    log()
-    
-    itemlist =[]
-    
-    support.menu(itemlist, 'ITA submenu bold', 'build_menu', host + '/filter?', args=["anime", 'language[]=1'])
-    support.menu(itemlist, 'Sub-ITA submenu bold', 'build_menu', host + '/filter?', args=["anime", 'language[]=0'])
-    support.menu(itemlist, 'Archivio A-Z submenu', 'alfabetico', host+'/az-list', args=["tvshow","a-z"])
-    support.menu(itemlist, 'In corso submenu', 'video', host+'/', args=["in sala"])
-    support.menu(itemlist, 'Generi submenu', 'generi', host+'/')
-    support.menu(itemlist, 'Ultimi Aggiunti bold', 'video', host+'/newest', args=["anime"])
-    support.menu(itemlist, 'Ultimi Episodi bold', 'video', host+'/updated', args=["novita'"])
-    support.menu(itemlist, 'Cerca...', 'search')
-    support.aplay(item, itemlist, list_servers, list_quality)
-    support.channel_config(item, itemlist)
-    return itemlist
-
-# Crea menu dei generi =================================================
-
-def generi(item):
-    log()
-    patron_block = r'</i>\sGeneri</a>\s*<ul class="sub">(.*?)</ul>'
-    patron = r'<a href="([^"]+)"\stitle="([^"]+)">'
-
-    return support.scrape(item, patron, ['url','title'], patron_block=patron_block, action='video')
+    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()
 
 
-# Crea Menu Filtro ======================================================
+@support.scrape
+def genres(item):
+    action = 'peliculas'
+    data = get_data(item)
 
-def build_menu(item):
-    log()
-    itemlist = []
-    support.menu(itemlist, 'Tutti bold submenu', 'video', item.url+item.args[1])
-    matches, data = support.match(item,r'<button class="btn btn-sm btn-default dropdown-toggle" data-toggle="dropdown"> (.*?) <span.*?>(.*?)<\/ul>',r'<form class="filters.*?>(.*?)<\/form>')
-    log('ANIME DATA =' ,data)
-    for title, html in matches:
-        if title not in 'Lingua Ordine':
-            support.menu(itemlist, title + ' submenu bold', 'build_sub_menu', html, args=item.args)
-            log('ARGS= ', item.args[0])
-            log('ARGS= ', html)
-    return itemlist
+    patronBlock = r'dropdown[^>]*>\s*Generi\s*<span.[^>]+>(?P<block>.*?)</ul>'
+    patronMenu = r'<input.*?name="(?P<name>[^"]+)" value="(?P<value>[^"]+)"\s*>[^>]+>(?P<title>[^<]+)</label>'
 
-# Crea SottoMenu Filtro ======================================================
+    def itemHook(item):
+        item.url = host + '/filter?' + item.name + '=' + item.value + '&sort='
+        return item
+    return locals()
 
-def build_sub_menu(item):
-    log()
-    itemlist = []
-    matches = re.compile(r'<input.*?name="([^"]+)" value="([^"]+)"\s*>[^>]+>([^<]+)<\/label>', re.DOTALL).findall(item.url)
-    for name, value, title in matches:
-        support.menu(itemlist, support.typo(title, 'bold'), 'video', host + '/filter?' + '&' + name + '=' + value + '&' + item.args[1])     
-    return itemlist
 
-# Novità ======================================================
+@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):
-    log()
-    itemlist = []
-    item = Item()
+    support.info(categoria)
+    item = support.Item()
+    lang = config.get_setting('lang', channel=item.channel)
     try:
         if categoria == "anime":
-            item.url = host + '/newest'
-            item.action = "video"
-            itemlist = video(item)
-
-            if itemlist[-1].action == "video":
-                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
-
-
-# Cerca ===========================================================
-
-def search(item, texto):
-    log(texto)
-    item.url = host + '/search?keyword=' + texto
-    try:
-        return video(item)
+            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():
-            logger.error("%s" % line)
+            support.logger.error("{0}".format(line))
         return []
 
 
-# Lista A-Z ====================================================
-
-def alfabetico(item):
-    return support.scrape(item, '<a href="([^"]+)" title="([^"]+)">', ['url', 'title'], patron_block=r'<span>.*?A alla Z.<\/span>.*?<ul>(.*?)<\/ul>', action='lista_anime')
-    
-
-def lista_anime(item):
-    log()
-    itemlist = []
-    matches ,data = support.match(item, r'<div class="item"><a href="([^"]+)".*?src="([^"]+)".*?data-jtitle="([^"]+)".*?>([^<]+)<\/a><p>(.*?)<\/p>')
-    for scrapedurl, scrapedthumb, scrapedoriginal, scrapedtitle, scrapedplot in matches:
-        
-        if scrapedoriginal == scrapedtitle:
-            scrapedoriginal=''
-        else:
-            scrapedoriginal = support.typo(scrapedoriginal,' -- []')
-
-        year = ''
-        lang = ''
-        infoLabels = {}
-        if '(' in scrapedtitle:
-            year = scrapertoolsV2.find_single_match(scrapedtitle, r'(\([0-9]+\))')
-            lang = scrapertoolsV2.find_single_match(scrapedtitle, r'(\([a-zA-Z]+\))')
-
-        infoLabels['year'] = year
-        title = scrapedtitle.replace(year,'').replace(lang,'').strip()
-        original = scrapedoriginal.replace(year,'').replace(lang,'').strip()
-        if lang: lang = support.typo(lang,'_ color kod')
-        longtitle = '[B]' + title + '[/B]' + lang + original
-
-        itemlist.append(
-                Item(channel=item.channel,
-                     extra=item.extra,
-                     contentType="episode",
-                     action="episodios",
-                     title=longtitle,
-                     url=scrapedurl,
-                     thumbnail=scrapedthumb,
-                     fulltitle=title,
-                     show=title,
-                     infoLabels=infoLabels,
-                     plot=scrapedplot,
-                     folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)    
-    autorenumber.renumber(itemlist)
-
-    # Next page
-    support.nextPage(itemlist, item, data, r'<a class="page-link" href="([^"]+)" rel="next"')
-
-    return itemlist
+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 []
 
 
-def video(item):
-    log()
-    itemlist = []
+@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)
 
-    matches, data = support.match(item, r'<a href="([^"]+)" class[^>]+><img src="([^"]+)"(.*?)data-jtitle="([^"]+)" .*?>(.*?)<\/a>', headers=headers)
+    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'
 
-    for scrapedurl, scrapedthumb ,scrapedinfo, scrapedoriginal, scrapedtitle in matches:
-        # Cerca Info come anno o lingua nel Titolo
-        year = ''
-        lang = ''
-        if '(' in scrapedtitle:
-            year = scrapertoolsV2.find_single_match(scrapedtitle, r'( \([0-9]+\))')
-            lang = scrapertoolsV2.find_single_match(scrapedtitle, r'( \([a-zA-Z]+\))')
-        
-        # Rimuove Anno e Lingua nel Titolo
-        title = scrapedtitle.replace(year,'').replace(lang,'').strip()
-        original = scrapedoriginal.replace(year,'').replace(lang,'').strip()
-        
-        # Compara Il Titolo con quello originale
-        if original == title:
-            original=''
-        else:
-            original = support.typo(scrapedoriginal,'-- []')
-
-        # cerca info supplementari
-        ep = ''
-        ep = scrapertoolsV2.find_single_match(scrapedinfo, '<div class="ep">(.*?)<')
-        if  ep != '':
-            ep = ' - ' + ep
-
-        ova = ''
-        ova = scrapertoolsV2.find_single_match(scrapedinfo, '<div class="ova">(.*?)<')
-        if  ova != '':
-            ova = ' - (' + ova + ')'
-        
-        ona = ''
-        ona = scrapertoolsV2.find_single_match(scrapedinfo, '<div class="ona">(.*?)<')
-        if  ona != '':
-            ona = ' - (' + ona + ')'
-
-        movie = ''
-        movie = scrapertoolsV2.find_single_match(scrapedinfo, '<div class="movie">(.*?)<')
-        if  movie != '':
-            movie = ' - (' + movie + ')'
-
-        special = ''
-        special = scrapertoolsV2.find_single_match(scrapedinfo, '<div class="special">(.*?)<')
-        if  special != '':
-            special = ' - (' + special + ')'
-
-
-        # Concatena le informazioni
-
-        lang = support.typo('Sub-ITA', '_ [] color kod') if '(ita)' not in lang.lower() else ''
-
-        info = ep + lang + year + ova + ona + movie + special
-
-        # Crea il title da visualizzare
-        long_title = '[B]' + title + '[/B]' + info + original
-
-        # Controlla se sono Episodi o Film
-        if movie == '':
-            contentType = 'tvshow'
-            action = 'episodios'
-        else:
-            contentType = 'movie'
-            action = 'findvideos'
-        
-        itemlist.append(
-                Item(channel=item.channel,
-                     contentType=contentType,
-                     action=action,
-                     title=long_title,
-                     url=scrapedurl,
-                     fulltitle=title,
-                     show=title,
-                     thumbnail=scrapedthumb,
-                     context = autoplay.context))
-    
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-    autorenumber.renumber(itemlist)
-
-    # Next page
-    support.nextPage(itemlist, item, data, r'<a\sclass="page-link"\shref="([^"]+)"\srel="next"\saria-label="Successiva')
-    return itemlist
+    # 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):
-    log()
-    itemlist = []
-    
-    patron_block = r'<div class="widget servers".*?>(.*?)<div id="download"'
-    patron = r'<li><a [^=]+="[^"]+"[^=]+="[^"]+"[^=]+="[^"]+"[^=]+="[^"]+"[^=]+="[^"]+" href="([^"]+)"[^>]+>([^<]+)<'
-    matches = support.match(item, patron, patron_block)[0]
-
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(
-            Item(
-                channel=item.channel,
-                action="findvideos",
-                contentType="episode",
-                title='[B] Episodio ' + scrapedtitle + '[/B]',
-                url=urlparse.urljoin(host, scrapedurl),
-                fulltitle=scrapedtitle,
-                show=scrapedtitle,
-                plot=item.plot,
-                fanart=item.thumbnail,
-                thumbnail=item.thumbnail))
-    
-    autorenumber.renumber(itemlist, item,'bold')
-    support.videolibrary(itemlist, item)
-    return itemlist
+    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):
-    log()
+    import time
+    support.info(item)
     itemlist = []
-   
-    matches, data = support.match(item, r'class="tab.*?data-name="([0-9]+)">([^<]+)</span', headers=headers)
-    videoData = ''
-    
-    for serverid, servername in matches:
-        block = scrapertoolsV2.find_multiple_matches(data,'data-id="'+serverid+'">(.*?)<div class="server')
-        id = scrapertoolsV2.find_single_match(str(block),r'<a data-id="([^"]+)" data-base="'+item.fulltitle+'"')
-        dataJson = httptools.downloadpage('%s/ajax/episode/info?id=%s&server=%s&ts=%s' % (host, id, serverid, int(time.time())), headers=[['x-requested-with', 'XMLHttpRequest']]).data
-        json = jsontools.load(dataJson)
-        log('JSON= ',json)
+    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
 
-        videoData +='\n'+json['grabber']
-
-        if serverid == '28':
-            itemlist.append(
-                Item(
-                    channel=item.channel,
-                    action="play",
-                    title='diretto',
-                    quality='',
-                    url=json['grabber'],
-                    server='directo',
-                    show=item.show,
-                    contentType=item.contentType,
-                    folder=False))
-
-    return support.server(item, videoData, itemlist)
+    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": false,
+    "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/bleachportal.json

@@ -1,22 +0,0 @@
-{
-	"id": "bleachportal",
-	"name": "BleachPortal",
-	"language": ["ita"],
-	"active": true,
-    "adult": false,
-    "fanart": "http://i39.tinypic.com/35ibvcx.jpg",
-	"thumbnail": "http://www.bleachportal.it/images/index_r1_c1.jpg",
-	"banner": "http://cgi.di.uoa.gr/~std05181/images/bleach.jpg",
-	"categories": ["anime"],
-	"settings": [
-		{
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Incluir en busqueda global",
-            "default": false,
-            "enabled": false,
-            "visible": false
-		}
-    ]
-}
-

channels/bleachportal.py

@@ -1,116 +0,0 @@
-# -*- coding: utf-8 -*-
-# Ringraziamo Icarus crew
-# ------------------------------------------------------------
-# XBMC Plugin
-# Canale per http://bleachportal.it
-# ------------------------------------------------------------
-
-import re
-
-from core import scrapertools, httptools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = "http://www.bleachportal.it"
-
-
-def mainlist(item):
-    logger.info("[BleachPortal.py]==> mainlist")
-    itemlist = [Item(channel=item.channel,
-                     action="episodi",
-                     title="[COLOR azure] Bleach [/COLOR] - [COLOR deepskyblue]Lista Episodi[/COLOR]",
-                     url=host + "/streaming/bleach/stream_bleach.htm",
-                     thumbnail="http://i45.tinypic.com/286xp3m.jpg",
-                     fanart="http://i40.tinypic.com/5jsinb.jpg",
-                     extra="bleach"),
-                Item(channel=item.channel,
-                     action="episodi",
-                     title="[COLOR azure] D.Gray Man [/COLOR] - [COLOR deepskyblue]Lista Episodi[/COLOR]",
-                     url=host + "/streaming/d.gray-man/stream_dgray-man.htm",
-                     thumbnail="http://i59.tinypic.com/9is3tf.jpg",
-                     fanart="http://wallpapercraft.net/wp-content/uploads/2016/11/Cool-D-Gray-Man-Background.jpg",
-                     extra="dgrayman")]
-
-    return itemlist
-
-
-def episodi(item):
-    logger.info("[BleachPortal.py]==> episodi")
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    patron = '<td>?[<span\s|<width="\d+%"\s]+?class="[^"]+">\D+([\d\-]+)\s?<[^<]+<[^<]+<[^<]+<[^<]+<.*?\s+?.*?<span style="[^"]+">([^<]+).*?\s?.*?<a href="\.*(/?[^"]+)">'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    animetitle = "Bleach" if item.extra == "bleach" else "D.Gray Man"
-    for scrapednumber, scrapedtitle, scrapedurl in matches:
-        scrapedtitle = scrapedtitle.decode('latin1').encode('utf8')
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 title="[COLOR azure]%s Ep: [COLOR deepskyblue]%s[/COLOR][/COLOR]" % (animetitle, scrapednumber),
-                 url=item.url.replace("stream_bleach.htm",scrapedurl) if "stream_bleach.htm" in item.url else item.url.replace("stream_dgray-man.htm", scrapedurl),
-                 plot=scrapedtitle,
-                 extra=item.extra,
-                 thumbnail=item.thumbnail,
-                 fanart=item.fanart,
-                 fulltitle="[COLOR red]%s Ep: %s[/COLOR] | [COLOR deepskyblue]%s[/COLOR]" % (animetitle, scrapednumber, scrapedtitle)))
-
-    if item.extra == "bleach":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="oav",
-                 title="[B][COLOR azure] OAV e Movies [/COLOR][/B]",
-                 url=item.url.replace("stream_bleach.htm", "stream_bleach_movie_oav.htm"),
-                 extra=item.extra,
-                 thumbnail=item.thumbnail,
-                 fanart=item.fanart))
-
-    return list(reversed(itemlist))
-
-
-def oav(item):
-    logger.info("[BleachPortal.py]==> oav")
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    patron = '<td>?[<span\s|<width="\d+%"\s]+?class="[^"]+">-\s+(.*?)<[^<]+<[^<]+<[^<]+<[^<]+<.*?\s+?.*?<span style="[^"]+">([^<]+).*?\s?.*?<a href="\.*(/?[^"]+)">'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapednumber, scrapedtitle, scrapedurl in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 title="[COLOR deepskyblue] " + scrapednumber + " [/COLOR]",
-                 url=item.url.replace("stream_bleach_movie_oav.htm", scrapedurl),
-                 plot=scrapedtitle,
-                 extra=item.extra,
-                 thumbnail=item.thumbnail,
-                 fulltitle="[COLOR red]" + scrapednumber + "[/COLOR] | [COLOR deepskyblue]" + scrapedtitle + "[/COLOR]"))
-
-    return list(reversed(itemlist))
-
-
-def findvideos(item):
-    logger.info("[BleachPortal.py]==> findvideos")
-    itemlist = []
-
-    if "bleach//" in item.url:
-        item.url = re.sub(r'\w+//', "", item.url)
-
-    data = httptools.downloadpage(item.url).data
-
-    if "bleach" in item.extra:
-        video = scrapertools.find_single_match(data, 'file: "(.*?)",')
-    else:
-        video = scrapertools.find_single_match(data, 'file=(.*?)&').rsplit('/', 1)[-1]
-
-    itemlist.append(
-        Item(channel=item.channel,
-             action="play",
-             title="[[COLOR orange]Diretto[/COLOR]] [B]%s[/B]" % item.title,
-             url=item.url.replace(item.url.split("/")[-1], "/" + video),
-             thumbnail=item.thumbnail,
-             fulltitle=item.fulltitle))
-    return itemlist

channels/bravoporn.json

@@ -1,15 +0,0 @@
-{
-  "id": "bravoporn",
-  "name": "bravoporn",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://www.bravoporn.com/v/images/logo.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-
-  ]
-}

channels/bravoporn.py

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'http://www.bravoporn.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Nuevas" , action="lista", url=host +"/latest-updates/"))
-    itemlist.append( Item(channel=item.channel, title="Popular" , action="lista", url=host + "/most-popular/"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/c/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/s/?q=%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<a href="([^"]+)" class="th">.*?'
-    patron += '<img src="([^"]+)".*?'
-    patron += '<span>([^"]+)</span>\s*(\d+) movies.*?</strong>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle,cantidad in matches:
-        scrapedplot = ""
-        scrapedtitle = scrapedtitle + " (" + cantidad + ")"
-        scrapedthumbnail = "http:" + scrapedthumbnail
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl) + "/latest/"
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron = '<div class=".*?video_block"><a href="([^"]+)".*?'
-    patron += '<img src="([^"]+)".*?alt="([^"]+)".*?'
-    patron += '<span class="time">([^"]+)</span>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle,duracion in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + duracion + "[/COLOR] " + scrapedtitle
-        thumbnail = "https:" + scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail,
-                              fanart=thumbnail, plot=plot, contentTitle = scrapedtitle))
-    next_page = scrapertools.find_single_match(data,'<a href="([^"]+)" class="next" title="Next">Next</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '<source src="([^"]+)" type=\'video/mp4\' title="HQ" />'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for scrapedurl  in matches:
-        itemlist.append(Item(channel=item.channel, action="play", title=item.title, url=scrapedurl))
-    return itemlist
-

channels/camwhoresbay.json

@@ -1,15 +0,0 @@
-{
-  "id": "camwhoresbay",
-  "name": "camwhoresbay",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "https://www.camwhoresbay.com/images/porntrex.ico",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-  ]
-}
-

channels/camwhoresbay.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'https://www.camwhoresbay.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Nuevos" , action="lista", url=host + "/latest-updates/"))
-    itemlist.append( Item(channel=item.channel, title="Mejor valorados" , action="lista", url=host + "/top-rated/"))
-    itemlist.append( Item(channel=item.channel, title="Mas vistos" , action="lista", url=host + "/most-popular/"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/categories/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    item.url = "%s/search/%s/" % (host, texto.replace("+", "-"))
-    item.extra = texto
-    try:
-        return lista(item)
-    # Se captura la excepción, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '<a class="item" href="([^"]+)" title="([^"]+)">.*?'
-    patron  += '<img class="thumb" src="([^"]+)".*?'
-    patron  += '<div class="videos">([^"]+)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,cantidad  in matches:
-        scrapedtitle = scrapedtitle + " (" + cantidad + ")"
-        scrapedplot = ""
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return sorted(itemlist, key=lambda i: i.title)
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron = '<div class="video-item   ">.*?'
-    patron += '<a href="([^"]+)" title="([^"]+)"  class="thumb">.*?'
-    patron += 'data-original="([^"]+)".*?'
-    patron += '<i class="fa fa-clock-o"></i>(.*?)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail,scrapedtime in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail, plot=plot,
-                              contentTitle = scrapedtitle, fanart=thumbnail))
-    if item.extra:
-       next_page = scrapertools.find_single_match(data, '<li class="next">.*?from_videos\+from_albums:(\d+)')
-       if next_page:
-           if "from_videos=" in item.url:
-               next_page = re.sub(r'&from_videos=(\d+)', '&from_videos=%s' % next_page, item.url)
-           else:
-               next_page = "%s?mode=async&function=get_block&block_id=list_videos_videos_list_search_result" \
-                           "&q=%s&category_ids=&sort_by=post_date&from_videos=%s" % (item.url, item.extra, next_page)
-           itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page))
-    else:
-        next_page = scrapertools.find_single_match(data, '<li class="next"><a href="([^"]+)"')
-        if next_page and not next_page.startswith("#"):
-            next_page = urlparse.urljoin(item.url,next_page)
-            itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-        else:
-            next_page = scrapertools.find_single_match(data, '<li class="next">.*?from:(\d+)')
-            if next_page:
-                if "from" in item.url:
-                    next_page = re.sub(r'&from=(\d+)', '&from=%s' % next_page, item.url)
-                else:
-                    next_page = "%s?mode=async&function=get_block&block_id=list_videos_common_videos_list&sort_by=post_date&from=%s" % (
-                         item.url, next_page)
-                itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page))
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    scrapedurl = scrapertools.find_single_match(data, 'video_alt_url3: \'([^\']+)\'')
-    if scrapedurl == "" :
-        scrapedurl = scrapertools.find_single_match(data, 'video_alt_url2: \'([^\']+)\'')
-    if scrapedurl == "" :
-        scrapedurl = scrapertools.find_single_match(data, 'video_alt_url: \'([^\']+)\'')
-    if scrapedurl == "" :
-        scrapedurl = scrapertools.find_single_match(data, 'video_url: \'([^\']+)\'')
-
-    itemlist.append(Item(channel=item.channel, action="play", title=scrapedurl, fulltitle=item.title, url=scrapedurl,
-                        thumbnail=item.thumbnail, plot=item.plot, show=item.title, server="directo"))
-    return itemlist
-
-

channels/canalporno.json

@@ -1,12 +0,0 @@
-{
-  "id": "canalporno",
-  "name": "Canalporno",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://i.imgur.com/gAbPcvT.png?1",
-  "banner": "canalporno.png",
-  "categories": [
-    "adult"
-  ]
-}

channels/canalporno.py

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from core import httptools
-from core import scrapertools
-from platformcode import logger
-from platformcode import config
-
-host = "http://www.canalporno.com"
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(item.clone(action="findvideos", title="Útimos videos", url=host))
-    itemlist.append(item.clone(action="categorias", title="Listado Categorias",
-                               url=host + "/categorias"))
-    itemlist.append(item.clone(action="search", title="Buscar", url=host + "/search/?q=%s"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-
-    try:
-        item.url = item.url % texto
-        itemlist = findvideos(item)
-        return sorted(itemlist, key=lambda it: it.title)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def findvideos(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    patron = '<img src="([^"]+)".*?alt="([^"]+)".*?<h2><a href="([^"]+)">.*?' \
-             '<div class="duracion"><span class="ico-duracion sprite"></span> ([^"]+) min</div>'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for thumbnail, title, url, time in matches:
-        scrapedtitle = time + " - " + title
-        scrapedurl = host + url
-        scrapedthumbnail = thumbnail
-        itemlist.append(item.clone(action="play", title=scrapedtitle, url=scrapedurl,
-                                   thumbnail=scrapedthumbnail))
-
-    patron = '<div class="paginacion">.*?<span class="selected">.*?<a href="([^"]+)">([^"]+)</a>'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for url, title in matches:
-        url = host + url
-        title = "Página %s" % title
-        itemlist.append(item.clone(action="findvideos", title=title, url=url))
-
-    return itemlist
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    bloque = scrapertools.find_single_match(data, '<ul class="ordenar-por ordenar-por-categoria">'
-                                                  '(.*?)<\/ul>')
-
-    #patron = '<div class="muestra-categorias">.*?<a class="thumb" href="([^"]+)".*?<img class="categorias" src="([^"]+)".*?<div class="nombre">([^"]+)</div>'
-    patron = "<li><a href='([^']+)'\s?title='([^']+)'>.*?<\/a><\/li>"
-    matches = scrapertools.find_multiple_matches(bloque, patron)
-    for url, title in matches:
-        url = host + url
-        #thumbnail = "http:" + thumbnail
-        itemlist.append(item.clone(action="findvideos", title=title, url=url))
-
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    url = scrapertools.find_single_match(data, '<source src="([^"]+)"')
-    itemlist.append(item.clone(url=url, server="directo"))
-
-    return itemlist

channels/casacinema.json

@@ -1,70 +1,11 @@
 {
     "id": "casacinema",
     "name": "Casacinema",
-    "language": ["ita"],
-    "active": true,
-    "adult": false,
-    "thumbnail": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/casacinema.png",
-    "banner": "https://raw.githubusercontent.com/Zanzibar82/images/master/posters/casacinema.png",
-    "categories": ["tvshow", "movie"],
+    "language": ["ita", "sub-ita"],
+    "active": false,
+    "thumbnail": "casacinema.png",
+    "banner": "casacinema.png",
+    "categories": ["tvshow", "movie","vos"],
     "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_series",
-            "type": "bool",
-            "label": "Includi in Novità - Serie TV",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "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": [ "5", "10", "15", "20" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-            }
     ]
 }

channels/casacinema.py

@@ -1,340 +1,145 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Kodi on Demand - Kodi Addon
-# Canale per casacinema
+# Canale per 'casacinema'
 # ------------------------------------------------------------
-import re
-import urlparse
-
-from channelselector import thumb, get_thumb
-from core import scrapertools, scrapertoolsV2, httptools, tmdb, support
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
-
-__channel__ = "casacinema"
-host = config.get_channel_url(__channel__)
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream', 'openload', 'wstream', 'speedvideo']
-list_quality = ['HD', 'SD']
-
-__comprueba_enlaces__ = config.get_setting('comprueba_enlaces', 'casacinema')
-__comprueba_enlaces_num__ = config.get_setting('comprueba_enlaces_num', 'casacinema')
-
-headers = [['Referer', '%s/genere/serie-tv' % host]]
 
 
+from core import support
+
+host = support.config.get_channel_url()
+headers = [['Referer', host]]
+
+
+@support.menu
 def mainlist(item):
-    logger.info("kod.casacinema mainlist")
+    film = ['/category/film',
+        ('Generi', ['', 'genres', 'genres']),
+        ]
 
-    autoplay.init(item.channel, list_servers, list_quality)
+    tvshow = ['/category/serie-tv',
+        ('Novità', ['/aggiornamenti-serie-tv', 'peliculas', '']),
+        ]
 
-    itemlist = [Item(channel=item.channel,
-                     title="[B]Film[/B]",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/genere/film" % host),
-                Item(channel=item.channel,
-                     title="[B]Film - HD[/B]",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/?s=[HD]" % host),
-                Item(channel=item.channel,
-                     title="[B] > Categorie[/B]",
-                     action="categorias",
-                     extra="movie",
-                     url="%s/genere/film" % host),
-                Item(channel=item.channel,
-                     title="[B]Film Sub - Ita[/B]",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/genere/sub-ita" % host),
-                Item(channel=item.channel,
-                     title="[COLOR blue]Cerca Film...[/COLOR]",
-                     action="search",
-                     extra="movie",),
-                Item(channel=item.channel,
-                     title="[B]Serie TV[/B]",
-                     extra="tvshow",
-                     action="peliculas_tv",
-                     url="%s/genere/serie-tv" % host),
-                Item(channel=item.channel,
-                     title="[COLOR blue]Cerca Serie TV...[/COLOR]",
-                     action="search",
-                     extra="tvshow")]
+    search = ''
 
-    
-    autoplay.show_option(item.channel, itemlist)
+    return locals()
 
-    # auto thumb
-    itemlist=thumb(itemlist) 
 
-    return itemlist
+@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):
-    logger.info("[casacinema.py] newest" + categoria)
     itemlist = []
-    item = Item()
+    item = support.Item()
+    item.args = 'newest'
+
     try:
-        if categoria == "film":
-            item.url = host + '/genere/film'
-            item.extra = "movie"
-            item.action = "peliculas"
-            itemlist = peliculas(item)
+        if categoria == 'series':
+            item.contentType = 'tvshow'
+            item.url = host+'/aggiornamenti-serie-tv'
 
-            if itemlist[-1].action == "peliculas":
-                itemlist.pop()
+        else:
+            item.contentType = 'movie'
+            item.url = host+'/category/film'
 
-    # Continua la ricerca in caso di errore 
+        item.action = 'peliculas'
+        itemlist = peliculas(item)
+
+        if itemlist[-1].action == 'peliculas':
+            itemlist.pop()
+
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
-            logger.error("{0}".format(line))
+            support.info("%s" % line)
         return []
 
     return itemlist
 
 
-def search(item, texto):
-    logger.info("[casacinema.py] " + item.url + " search " + texto)
-
-    item.url = host + "/?s=" + texto
-
-    try:
-        if item.extra == "tvshow":
-            return peliculas_tv(item)
-        if item.extra == "movie":
-            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):
-    logger.info("kod.casacinema peliculas")
+    if item.contentType == 'movie':
+        action = 'findvideos'
+    elif item.contentType == 'tvshow':
+        action = 'episodios'
+        pagination = ''
+    else:
+        action = 'check'
 
-    itemlist = []
+    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}\))?<'
 
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url, headers=headers).data
-    logger.info('DATA=' +data)
-
-    # Estrae i contenuti 
-    patron = '<li><a href="([^"]+)"[^=]+="([^"]+)"><div>\s*<div[^>]+>(.*?)<'
-
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
-        title = scrapertools.decodeHtmlentities(scrapedtitle)
-        cleantitle = re.sub(r'[-–]*\s*[Ii]l [Ff]ilm\s*[-–]*?', '', title).strip()
-        cleantitle = cleantitle.replace('[HD]', '').strip()
-
-        year = scrapertools.find_single_match(title, r'\((\d{4})\)')
-        infolabels = {}
-        if year:
-            cleantitle = cleantitle.replace("(%s)" % year, '').strip()
-            infolabels['year'] = year
-
-        scrapedplot = ""
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="movie",
-                 title=title,
-                 text_color="azure",
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fulltitle=cleantitle,
-                 show=cleantitle,
-                 plot=scrapedplot,
-                 infoLabels=infolabels,
-                 extra=item.extra,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    ## Paginación
-    next_page = scrapertools.find_single_match(data, '<li><a href="([^"]+)".*?>Pagina')
-
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR blue]" + config.get_localized_string(30992) + " >[/COLOR]",
-                 url=next_page,
-                 extra=item.extra,
-                 thumbnail=get_thumb('next.png')))
-
-    return itemlist
+    patronNext = r'<a href="([^"]+)"\s*>Pagina'
 
 
-def peliculas_tv(item):
-    logger.info("kod.casacinema peliculas")
+    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
 
-    itemlist = []
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    # Estrae i contenuti 
-    patron = '<li><a href="([^"]+)"[^=]+="([^"]+)"><div>\s*<div[^>]+>(.*?)<'
-
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
-        title = scrapertools.decodeHtmlentities(scrapedtitle)
-        cleantitle = re.sub(r'[-–]*\s*[Ss]erie [Tt]v\s*[-–]*?', '', title).strip()
-        cleantitle = cleantitle.replace('[HD]', '').replace('[SD]', '').strip()
-
-        year = scrapertools.find_single_match(title, r'\((\d{4})\)')
-        infolabels = {}
-        if year:
-            cleantitle = cleantitle.replace("(%s)" % year, '').strip()
-            infolabels['year'] = year
-
-        scrapedplot = ""
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="episodios",
-                 contentType="tvshow",
-                 title=title,
-                 text_color="azure",
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fulltitle=cleantitle,
-                 show=cleantitle,
-                 plot=scrapedplot,
-                 infoLabels=infolabels,
-                 extra=item.extra,
-                 folder=True))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    ## Paginación
-    next_page = scrapertools.find_single_match(data, '<li><a href="([^"]+)">Pagina') ### <- Regex rimosso spazio - precedente <li><a href="([^"]+)" >Pagina
-
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas_tv",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=next_page,
-                 extra=item.extra,
-                 thumbnail=get_thumb('next.png')))
-
-    return itemlist
-
-def categorias(item):
-    logger.info("kod.casacinema categorias")
-
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    # Narrow search by selecting only the combo
-    bloque = scrapertools.find_single_match(data, 'Categorie(.*?)</ul>')
-
-    # The categories are the options for the combo
-    patron = '<a href="(.*?)">(.*?)</a></li>'
-    matches = re.compile(patron, re.DOTALL).findall(bloque)
-
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
-                 extra=item.extra,
-                 url=urlparse.urljoin(host, scrapedurl)))
-
-    return itemlist
+        return item
+    return locals()
 
 
+@support.scrape
 def episodios(item):
-    def load_episodios(html, item, itemlist, lang_title):
-        patron = '.*?<a href="[^"]+"[^o]+ofollow[^>]+>[^<]+</a><(?:b|/)[^>]+>'
-        matches = re.compile(patron).findall(html)
-        for data in matches:
-            # Estrae i contenuti
-            scrapedtitle = scrapertoolsV2.htmlclean(re.sub(r'(<a [^>]+>)*(<\/a>.*)*(Speedvideo)*', '', data)).strip()
-            if scrapedtitle != 'Categorie':
-                scrapedtitle = scrapedtitle.replace('&#215;', 'x')
-                scrapedtitle = scrapedtitle.replace('×', 'x')
-                scrapedtitle = scrapedtitle.replace(';', '')
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action="findvideos",
-                         contentType="episode",
-                         title="[COLOR azure]%s[/COLOR]" % (scrapedtitle + " (" + lang_title + ")"),
-                         url=data,
-                         thumbnail=item.thumbnail,
-                         extra=item.extra,
-                         fulltitle=scrapedtitle + " (" + lang_title + ")" + ' - ' + item.show,
-                         show=item.show))
-
-    logger.info("[casacinema.py] episodios")
-
-    itemlist = []
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
-    data = scrapertools.decodeHtmlentities(data)
-    data = scrapertools.find_single_match(data, '<p>(?:<strong>|)(.*?)<div id="disqus_thread">')
-
-    lang_titles = []
-    starts = []
-    patron = r"Stagione.*?(?:ITA|\d+)"
-    matches = re.compile(patron, re.IGNORECASE).finditer(data)
-    for match in matches:
-        season_title = match.group()
-        if season_title != '':
-            lang_titles.append('SUB ITA' if 'SUB' in season_title.upper() else 'ITA')
-            starts.append(match.end())
-
-    i = 1
-    len_lang_titles = len(lang_titles)
-
-    while i <= len_lang_titles:
-        inizio = starts[i - 1]
-        fine = starts[i] if i < len_lang_titles else -1
-
-        html = data[inizio:fine]
-        lang_title = lang_titles[i - 1]
-
-        load_episodios(html, item, itemlist, lang_title)
-
-        i += 1
-
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios" + "###" + item.extra,
-                 show=item.show))
-
-    return itemlist
+    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):
-    logger.info("kod.casacinema findvideos")
-
-    data = item.url if item.extra == "tvshow" else httptools.downloadpage(item.url, headers=headers).data
-
-    html = httptools.downloadpage(data).data
-    patron = '"http:\/\/shrink-service\.it\/[^\/]+\/[^\/]+\/([^"]+)"'
-    matches = re.compile(patron, re.DOTALL).findall(html)
-
-    for url in matches:
-        if url is not None:
-            data = data
-        else:
-            continue
-    
-    return support.server(item, data=data)
+    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/casacinemaInfo.json

@@ -1,36 +0,0 @@
-{
-    "id": "casacinemaInfo",
-    "name": "La casa del cinema",
-    "language": ["ita"],
-    "active": true,
-    "adult": false,
-    "thumbnail": "",
-    "banner": "",
-    "categories": ["movie"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        }
-    ]
-}

channels/casacinemaInfo.py

@@ -1,151 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per casacinema
-# ------------------------------------------------------------
-
-from core import scrapertoolsV2, httptools, servertools, tmdb, support
-from core.item import Item
-from platformcode import logger, config
-from specials import autoplay
-
-__channel__ = "casacinemainfo"
-host = config.get_channel_url(__channel__)
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream', 'openload', 'wstream', 'speedvideo']
-list_quality = ['1080p', '720', '480p', '360p']
-
-checklinks = config.get_setting('checklinks', 'casacinema')
-checklinks_number = config.get_setting('checklinks_number', 'casacinema')
-
-
-def mainlist(item):
-    logger.info("alfa.casacinema mainlist")
-
-    autoplay.init(item.channel, list_servers, list_quality)
-
-    itemlist = [Item(channel=item.channel,
-                     title="Film",
-                     action="peliculas",
-                     extra="movie",
-                     url=host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     title="In sala",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/category/in-sala/" % host,
-                     thumbnail="http://jcrent.com/apple%20tv%20final/HD.png"),
-                Item(channel=item.channel,
-                     title="Novità",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/category/nuove-uscite/" % host,
-                     thumbnail="http://orig03.deviantart.net/6889/f/2014/079/7/b/movies_and_popcorn_folder_icon_by_matheusgrilo-d7ay4tw.png"),
-                Item(channel=item.channel,
-                     title="Sub - Ita",
-                     action="peliculas",
-                     extra="movie",
-                     url="%s/category/sub-ita/" % host,
-                     thumbnail="http://i.imgur.com/qUENzxl.png"),
-                Item(channel=item.channel,
-                     title="[COLOR yellow]Cerca...[/COLOR]",
-                     action="search",
-                     extra="movie",
-                     thumbnail="http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")]
-
-    
-    autoplay.show_option(item.channel, itemlist)
-
-    return itemlist
-
-
-def search(item, texto):
-    logger.info("[casacinemaInfo.py] " + item.url + " search " + texto)
-
-    item.url = host + "/?s=" + texto
-    data = httptools.downloadpage(item.url).data
-
-    itemlist = []
-
-    patron = '<li class="col-md-12 itemlist">.*?<a href="([^"]+)" title="([^"]+)".*?<img src="([^"]+)".*?Film dell\\\'anno: ([0-9]{4}).*?<p class="text-list">([^<>]+)</p>'
-    matches = scrapertoolsV2.find_multiple_matches(data, patron)
-    for scrapedurl, scrapedtitle, scrapedthumbnail, scrapedyear, scrapedplot in matches:
-        title = scrapertoolsV2.decodeHtmlentities(scrapedtitle)
-        cleantitle = title.replace('[Sub-ITA]', '').strip()
-
-        infoLabels = {"plot": scrapertoolsV2.decodeHtmlentities(scrapedplot), "year": scrapedyear}
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="movie",
-                 title=title,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 infoLabels=infoLabels,
-                 fulltitle=cleantitle))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    return itemlist
-
-
-def peliculas(item):
-    logger.info("[casacinemaInfo.py] peliculas")
-
-    itemlist = []
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
-
-    # Estrae i contenuti
-
-    patron = '<div class="col-mt-5 postsh">[^<>]+<div class="poster-media-card">[^<>]+<a href="([^"]+)" title="([^"]+)".*?<img src="([^"]+)"'
-
-    matches = scrapertoolsV2.find_multiple_matches(data, patron)
-
-    for scrapedurl, scrapedtitle, scrapedthumbnail in matches:
-        title = scrapertoolsV2.decodeHtmlentities(scrapedtitle)
-        cleantitle = title.replace('[Sub-ITA]', '').strip()
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType="movie",
-                 title=title,
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 fulltitle=cleantitle))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    ## Paginación
-    next_page = scrapertoolsV2.find_single_match(data, '<a href="([^"]+)"><i class="glyphicon glyphicon-chevron-right"')  ### <- Regex rimosso spazio - precedente <li><a href="([^"]+)" >Pagina -> Continua. riga 221
-
-    if next_page != "":
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=next_page,
-                 extra=item.extra,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"))
-
-    return itemlist
-
-
-def findvideos(item):
-    logger.info("[casacinemaInfo.py] findvideos")
-
-    itemlist = support.hdpass_get_servers(item)
-
-    # Requerido para Filtrar enlaces
-
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # Requerido para AutoPlay
-
-    autoplay.start(itemlist, item)
-    return itemlist

channels/cat3plus.json

@@ -1,14 +0,0 @@
-{
-  "id": "cat3plus",
-  "name": "Cat3plus",
-  "active": true,
-  "adult": true,
-  "language": [],
-  "thumbnail": "https://i.imgur.com/SJxXKa2.png",
-  "fanart": "https://i.imgur.com/ejCwTxT.jpg",
-  "banner": "https://i.imgur.com/bXUyk6m.png",
-  "categories": [
-    "movie",
-    "vo"
-  ]
-}

channels/cat3plus.py

@@ -1,129 +0,0 @@
-# -*- coding: utf-8 -*-
-# -*- Channel SleazeMovies -*-
-# -*- Created for Alfa-addon -*-
-# -*- By Sculkurt -*-
-
-
-import re
-
-from channelselector import get_thumb
-from core import httptools
-from core import scrapertools
-from core import servertools
-from core import tmdb
-from core.item import Item
-from platformcode import config, logger
-
-host = 'http://www.cat3plus.com/'
-
-headers = [
-    ['User-Agent', 'Mozilla/5.0 (Windows NT 6.1; rv:38.0) Gecko/20100101 Firefox/38.0'],
-    ['Accept-Encoding', 'gzip, deflate'],
-    ['Referer', host]
-]
-
-def mainlist(item):
-    logger.info()
-
-    itemlist = list()
-    itemlist.append(item.clone(title="Todas", action="list_all", url=host, thumbnail=get_thumb('all', auto=True)))
-    itemlist.append(item.clone(title="Años", action="years", url=host, thumbnail=get_thumb('year', auto=True)))
-    itemlist.append(item.clone(title="Buscar", action="search", thumbnail=get_thumb('search', auto=True)))
-
-    return itemlist
-
-def years(item):
-    logger.info()
-    itemlist = list()
-    data = httptools.downloadpage(item.url, cookies=False).data
-    data = re.sub(r"\n|\r|\t|\s{2}| ", "", data)
-    patron = "<a dir='ltr' href='([^']+)'>([^<]+)</a>"
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(item.clone(action='list_all', title=scrapedtitle, url=scrapedurl))
-    return itemlist
-
-def get_source(url):
-    logger.info()
-    data = httptools.downloadpage(url).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    return data
-
-
-def list_all(item):
-    logger.info()
-    itemlist = []
-    data = get_source(item.url)
-
-    patron = "<h2 class='post-title entry-title'><a href='([^']+)'>([^(]+).*?\(([^)]+).*?"
-    patron += 'src="([^"]+).*?'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedtitle, year, img in matches:
-        itemlist.append(Item(channel = item.channel,
-                             title = scrapedtitle, 
-                             url = scrapedurl, 
-                             action = "findvideos",
-                             thumbnail = img,
-                             contentTitle = scrapedtitle,
-                             contentType = "movie",
-                             infoLabels = {'year': year}))
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb = True)
-
-    # Extraer la marca de siguiente página
-    next_page = scrapertools.find_single_match(data, "<a class='blog-pager-older-link' href='([^']+)'")
-    if next_page != "":
-	itemlist.append(Item(channel=item.channel, action="list_all", title=">> Página siguiente", url=next_page, folder=True))
-	
-    return itemlist
-
-
-    
-def search(item, texto):
-    logger.info()
-    if texto != "":
-        texto = texto.replace(" ", "+")
-    item.url = host + "/search?q=" + texto
-    item.extra = "busqueda"
-    try:
-        return list_all(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-         
-
-def findvideos(item):
-    logger.info()
-
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    
-    patron = '<h2>\s*<a href="([^"]+)" target="_blank">.*?</a></h2>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for url in matches:
-        data = httptools.downloadpage(url,	headers={'Referer': item.url}).data
-
-        itemlist.extend(servertools.find_video_items(data=data)) 
-
-    for video in itemlist: 
-
-        video.channel = item.channel
-        video.contentTitle = item.contentTitle
-        video.title = video.server.capitalize()
-
-	# Opción "Añadir esta pelicula a la videoteca"
-    if config.get_videolibrary_support() and len(itemlist) > 0 and item.extra != 'findvideos':
-        itemlist.append(Item(channel = item.channel, 
-                             title = '[COLOR yellow]Añadir esta pelicula a la videoteca[/COLOR]',
-                             url = item.url,
-                             action = "add_pelicula_to_library",
-                             extra = "findvideos",
-                             contentTitle = item.contentTitle,
-                             thumbnail = item.thumbnail
-                             ))
-
-    return itemlist

channels/cb01anime.json

@@ -1,36 +1,10 @@
 {
-	"id": "cb01anime",
-	"name": "Cb01anime",
-	"language": ["ita"],
-	"active": true,
-	"adult": false,
-	"thumbnail": "http://i.imgur.com/bHoUMo2.png",
-	"banner": "http://i.imgur.com/bHoUMo2.png",
-	"categories": ["anime"],
-	"settings": [
-		{
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi in Ricerca Globale",
-            "default": false,
-            "enabled": false,
-            "visible": false
-		},
-		{
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": false,
-            "enabled": false,
-            "visible": false
-		},
-		{
-			"id": "include_in_newest_italiano",
-			"type": "bool",
-			"label": "Includi in Novità - Italiano",
-			"default": true,
-			"enabled": true,
-			"visible": true
-		}
-	  ]
-}
+    "id": "cb01anime",
+    "name": "Cb01anime",
+    "language": ["ita", "vos", "sub-ita"],
+    "active": false,
+    "thumbnail": "cb01anime.png",
+    "banner": "cb01anime.png",
+    "categories": ["anime"],
+    "settings": []
+}

channels/cb01anime.py

@@ -1,276 +1,139 @@
 # -*- coding: utf-8 -*-
-# Ringraziamo Icarus crew
 # ------------------------------------------------------------
 # XBMC Plugin
 # Canale  per cineblog01 - anime
 # ------------------------------------------------------------
-import re
 
-from core import httptools, scrapertools, servertools, tmdb
-from core.item import Item
-from platformcode import logger, config
+from core import support
 
-__channel__ = "cb01anime"
-host = config.get_channel_url(__channel__)
-#esclusione degli articoli 'di servizio'
-blacklist = ['AVVISO IMPORTANTE – CB01.ROCKS', 'Lista Alfabetica Completa Anime/Cartoon', 'CB01.UNO ▶ TROVA L’INDIRIZZO UFFICIALE']
+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):
-    logger.info("[cb01anime.py] mainlist")
-
-    # Main options
-    itemlist = [Item(channel=item.channel,
-                     action="list_titles",
-                     title="[COLOR azure]Anime - Novita'[/COLOR]",
-                     url=host + '/anime',
-                     thumbnail="http://orig09.deviantart.net/df5a/f/2014/169/2/a/fist_of_the_north_star_folder_icon_by_minacsky_saya-d7mq8c8.png"),
-                Item(channel=item.channel,
-                     action="genere",
-                     title="[COLOR azure]Anime - Per Genere[/COLOR]",
-                     url=host + '/anime',
-                     thumbnail="http://xbmc-repo-ackbarr.googlecode.com/svn/trunk/dev/skin.cirrus%20extended%20v2/extras/moviegenres/Genres.png"),
-                Item(channel=item.channel,
-                     action="alfabetico",
-                     title="[COLOR azure]Anime - Per Lettera A-Z[/COLOR]",
-                     url=host + '/anime',
-                     thumbnail="http://i.imgur.com/IjCmx5r.png"),
-                Item(channel=item.channel,
-                     action="listacompleta",
-                     title="[COLOR azure]Anime - Lista Completa[/COLOR]",
-                     url="%s/anime/lista-completa-anime-cartoon/" % host,
-                     thumbnail="http://i.imgur.com/IjCmx5r.png"),
-                Item(channel=item.channel,
-                     action="search",
-                     title="[COLOR yellow]Cerca Anime[/COLOR]",
-                     extra="anime",
-                     thumbnail="http://dc467.4shared.com/img/fEbJqOum/s7/13feaf0c8c0/Search")]
-
-    return itemlist
+    anime = [('Genere',['','menu', '2']),
+             ('Per Lettera',['','menu', '1']),
+             ('Per Anno',['','menu', '3']),
+             ('Ultimi Anime Aggiornati',['','peliculas', 'newest'])]
+    return locals()
 
 
-# =================================================================
-
-# -----------------------------------------------------------------
-def genere(item):
-    logger.info("[cb01anime.py] genere")
-
-    return build_itemlist(item, '<select name="select2"(.*?)</select>', '<option value="([^"]+)">([^<]+)</option>',
-                          "list_titles")
+@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 alfabetico(item):
-    logger.info("[cb01anime.py] alfabetico")
-
-    return build_itemlist(item, '<option value=\'-1\'>Anime per Lettera</option>(.*?)</select>',
-                          '<option value="([^"]+)">\(([^<]+)\)</option>', "list_titles")
-
-
-def listacompleta(item):
-    logger.info("[cb01anime.py] listacompleta")
-
-    return build_itemlist(item,
-                          '<a href="#char_5a" title="Go to the letter Z">Z</a></span></div>(.*?)</ul></div><div style="clear:both;"></div></div>',
-                          '<li><a href="' + host + '/([^"]+)"><span class="head">([^<]+)</span></a></li>', "episodios")
-
-
-def build_itemlist(item, re_bloque, re_patron, iaction):
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    # Narrow search by selecting only the combo
-    bloque = scrapertools.find_single_match(data, re_bloque)
-
-    # The categories are the options for the combo
-    matches = re.compile(re_patron, re.DOTALL).findall(bloque)
-    scrapertools.printMatches(matches)
-
-    for url, titulo in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action=iaction,
-                 contentType="tvshow",
-                 title=titulo,
-                 fulltitle=titulo,
-                 text_color="azure",
-                 show=titulo,
-                 url=host + url,
-                 plot=""))
-
-    return itemlist
-
-
-# =================================================================
-
-
-# -----------------------------------------------------------------
 def search(item, texto):
-    logger.info("[cb01anime.py] " + item.url + " search " + texto)
-
-    item.url = host + "/anime/?s=" + texto
-
-    return list_titles(item)
-
-
-# =================================================================
-
-# -----------------------------------------------------------------
-def list_titles(item):
-    logger.info("[cb01anime.py] mainlist")
-    itemlist = []
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
-
-    # Estrae i contenuti 
-    patronvideos = r'<div class="span4">\s*<a href="([^"]+)">'
-    patronvideos += r'<img src="([^"]+)"[^>]+><\/a>[^>]+>[^>]+>'
-    patronvideos += r'[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>(.*?)<\/a>'
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
-        scrapedtitle = scrapertools.htmlclean(scrapedtitle).strip()
-        if not scrapedtitle in blacklist:
-            if 'lista richieste' in scrapedtitle.lower(): continue
-
-            patron = r'(?:\[[Ff][Uu][Ll]{2}\s*[Ii][Tt][Aa]\]|\[[Ss][Uu][Bb]\s*[Ii][Tt][Aa]\])'
-            cleantitle = re.sub(patron, '', scrapedtitle).strip()
-
-            ## ------------------------------------------------
-            scrapedthumbnail = httptools.get_url_headers(scrapedthumbnail)
-            ## ------------------------------------------------
-
-            # Añade al listado de XBMC
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="listacompleta" if "Lista Alfabetica Completa Anime/Cartoon" in scrapedtitle else "episodios",
-                    contentType="tvshow",
-                    title=scrapedtitle,
-                    fulltitle=cleantitle,
-                    text_color="azure",
-                    show=cleantitle,
-                    url=scrapedurl,
-                    thumbnail=scrapedthumbnail,
-                    viewmode="movie_with_plot"))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    # Put the next page mark
+    support.info(texto)
+    item.url = host + "/search/" + texto
     try:
-        next_page = scrapertools.find_single_match(data, "<link rel='next' href='([^']+)'")
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="list_titles",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url=next_page,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png"))
+        return peliculas(item)
     except:
-        pass
+        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):
-    logger.info("[cb01anime.py] episodios")
+    support.info('EPISODIOS ', item.data)
+    data = ''
+    matches = item.data
+    season = 1
+    s = 1
+    e = 0
+    sp = 0
 
-    itemlist = []
+    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
 
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data
-    # data = scrapertools.decodeHtmlentities(data)
+    patron = r'(?P<title>[^\|]+)\|(?P<url>[^\|]+)\|'
+    action = 'findvideos'
+    return locals()
 
-    patron1 = '(?:<p>|<td bgcolor="#ECEAE1">)<span class="txt_dow">(.*?)(?:</p>)?(?:\s*</span>)?\s*</td>'
-    patron2 = '<a.*?href="([^"]+)"[^>]*>([^<]+)</a>'
-    matches1 = re.compile(patron1, re.DOTALL).findall(data)
-    if len(matches1) > 0:
-        for match1 in re.split('<br />|<p>', matches1[0]):
-            if len(match1) > 0:
-                # Estrae i contenuti 
-                titulo = None
-                scrapedurl = ''
-                matches2 = re.compile(patron2, re.DOTALL).finditer(match1)
-                for match2 in matches2:
-                    if titulo is None:
-                        titulo = match2.group(2)
-                    scrapedurl += match2.group(1) + '#' + match2.group(2) + '|'
-                if titulo is not None:
-                    title = item.title + " " + titulo
-                    itemlist.append(
-                        Item(channel=item.channel,
-                             action="findvideos",
-                             contentType="episode",
-                             title=title,
-                             extra=scrapedurl,
-                             fulltitle=item.fulltitle,
-                             show=item.show))
-
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
-
-    return itemlist
-
-
-# =================================================================
-
-
-# -----------------------------------------------------------------
 def findvideos(item):
-    logger.info("[cb01anime.py] findvideos")
-
-    itemlist = []
-
-    for match in item.extra.split(r'|'):
-        match_split = match.split(r'#')
-        scrapedurl = match_split[0]
-        if len(scrapedurl) > 0:
-            scrapedtitle = match_split[1]
-            title = item.title + " [COLOR blue][" + scrapedtitle + "][/COLOR]"
-            itemlist.append(
-                Item(channel=item.channel,
-                     action="play",
-                     title=title,
-                     url=scrapedurl,
-                     fulltitle=item.fulltitle,
-                     show=item.show,
-                     ontentType=item.contentType,
-                     folder=False))
-
-    return itemlist
-
-
-# =================================================================
-
-
-# -----------------------------------------------------------------
-def play(item):
-    logger.info("[cb01anime.py] play")
-
-    if '/goto/' in item.url:
-        item.url = item.url.split('/goto/')[-1].decode('base64')
-
-    data = item.url
-
-    logger.debug("##### Play data ##\n%s\n##" % data)
-    itemlist = servertools.find_video_items(data=data)
-
-    for videoitem in itemlist:
-        videoitem.title = item.show
-        videoitem.fulltitle = item.fulltitle
-        videoitem.show = item.show
-        videoitem.thumbnail = item.thumbnail
-        videoitem.channel = item.channel
-        videoitem.contentType = item.contentType
-
-    return itemlist
+    return support.server(item, item.url)
 

channels/cineblog01.json

@@ -1,65 +1,10 @@
 {
 	"id": "cineblog01",
 	"name": "CB01",
-	"language": ["ita"],
+	"language": ["ita", "sub-ita"],
 	"active": true,
-	"adult": false,
 	"thumbnail": "cb01.png",
 	"banner": "cb01.png",
-	"categories": ["tvshow", "movie", "vosi"],
-	"settings": [
-		{
-		  "id": "include_in_global_search",
-		  "type": "bool",
-		  "label": "Includi in Ricerca Globale",
-		  "default": true,
-		  "enabled": true,
-		  "visible": true
-		},
-		{
-      "id": "include_in_newest_peliculas",
-      "type": "bool",
-      "label": "Includi in Novità - Film",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_italiano",
-      "type": "bool",
-      "label": "Includi in Novità - Italiano",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-		{
-      "id": "checklinks",
-      "type": "bool",
-      "label": "Verifica se i link esistono",
-      "default": false,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "checklinks_number",
-      "type": "list",
-      "label": "Numero di link da verificare",
-      "default": 1,
-      "enabled": true,
-      "visible": "eq(-1,true)",
-      "lvalues": [ "5", "10", "15", "20" ]
-    },
-    {
-      "id": "filter_languages",
-      "type": "list",
-      "label": "Mostra link in lingua...",
-      "default": 0,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "No filtrar",
-        "Italiano"
-      ]
-    }
-	  ]
-}
+	"categories": ["tvshow", "movie", "vos", "documentary"],
+	"settings": []
+}

channels/cineblog01.py

@@ -2,98 +2,88 @@
 # ------------------------------------------------------------
 # Canale per cineblog01
 # ------------------------------------------------------------
-
 import re
 
-from core import scrapertoolsV2, httptools, servertools, tmdb, support
-from core.item import Item
-from lib import unshortenit
+from core import scrapertools, httptools, servertools, support
 from platformcode import logger, config
-from specials import autoplay
-
-#impostati dinamicamente da getUrl()
-host = ""
-headers = ""
 
 
-def findhost():
-    global host, headers
-    permUrl = httptools.downloadpage('https://www.cb01.uno/', follow_redirects=False).headers
-    host = 'https://www.'+permUrl['location'].replace('https://www.google.it/search?q=site:', '')
-    headers = [['Referer', host]]
-
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['verystream', 'openload', 'streamango', 'wstream']
-list_quality = ['HD', 'SD', 'default']
-
-checklinks = config.get_setting('checklinks', 'cineblog01')
-checklinks_number = config.get_setting('checklinks_number', 'cineblog01')
-
-# esclusione degli articoli 'di servizio'
-blacklist = ['BENVENUTI', 'Richieste Serie TV', 'CB01.UNO ▶ TROVA L’INDIRIZZO UFFICIALE ',
-             'Aggiornamento Quotidiano Serie TV', 'OSCAR 2019 ▶ CB01.UNO: Vota il tuo film preferito! 🎬',
-             'Openload: la situazione. Benvenuto Verystream', 'Openload: lo volete ancora?']
+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):
-    findhost()
+    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'])
+            ]
 
-    autoplay.init(item.channel, list_servers, list_quality)
-
-    # Main options
-    itemlist = []
-    support.menu(itemlist, 'Ultimi 100 Film Aggiornati bold', 'last', host + '/lista-film-ultimi-100-film-aggiornati/')
-
-    support.menu(itemlist, 'Film bold', 'peliculas', host)
-    support.menu(itemlist, 'HD submenu', 'menu', host, args="Film HD Streaming")
-    support.menu(itemlist, 'Per genere submenu', 'menu', host, args="Film per Genere")
-    support.menu(itemlist, 'Per anno submenu', 'menu', host, args="Film per Anno")
-    support.menu(itemlist, 'Cerca film... submenu', 'search', host, args='film')
-
-    support.menu(itemlist, 'Serie TV bold', 'peliculas', host + '/serietv/', contentType='tvshow')
-    support.menu(itemlist, 'Aggiornamenti serie tv', 'last', host + '/serietv/aggiornamento-quotidiano-serie-tv/', contentType='tvshow')
-    support.menu(itemlist, 'Per Lettera submenu', 'menu', host + '/serietv/', contentType='tvshow', args="Serie-Tv per Lettera")
-    support.menu(itemlist, 'Per Genere submenu', 'menu', host + '/serietv/', contentType='tvshow', args="Serie-Tv per Genere")
-    support.menu(itemlist, 'Per anno submenu', 'menu', host + '/serietv/', contentType='tvshow', args="Serie-Tv per Anno")
-    support.menu(itemlist, 'Cerca serie... submenu', 'search', host + '/serietv/', contentType='tvshow', args='serie')
-    
-    autoplay.show_option(item.channel, itemlist)
-
-    return itemlist
+    return locals()
 
 
+@support.scrape
 def menu(item):
-    findhost()
-    itemlist= []
-    data = httptools.downloadpage(item.url, headers=headers).data
-    data = re.sub('\n|\t', '', data)
-    block = scrapertoolsV2.find_single_match(data, item.args + r'<span.*?><\/span>.*?<ul.*?>(.*?)<\/ul>')
-    support.log('MENU BLOCK= ',block)
-    patron = r'href="?([^">]+)"?>(.*?)<\/a>'
-    matches = re.compile(patron, re.DOTALL).findall(block)
-    for scrapedurl, scrapedtitle in matches:
-        itemlist.append(
-            Item(
-                channel=item.channel,
-                title=scrapedtitle,
-                contentType=item.contentType,
-                action='peliculas',
-                url=host + scrapedurl
-            )
-        )
-    
-    return support.thumb(itemlist)
+    # 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):
-    support.log(item.url, "search" ,text)
-
+    logger.info("search", text)
+    if item.contentType == 'tvshow': item.url = host + '/serietv'
+    else: item.url = host
     try:
-        item.url = item.url + "/?s=" + text
+        item.url = item.url + "/search/" + text.replace(' ', '+')
         return peliculas(item)
 
-    # Continua la ricerca in caso di errore 
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
@@ -101,179 +91,137 @@ def search(item, text):
         return []
 
 
-def newest(categoria):
-    findhost()
-    itemlist = []
-    item = Item()
-    item.contentType = 'movie'
-    item.url = host + '/lista-film-ultimi-100-film-aggiunti/'
-    return support.scrape(item, r'<a href=([^>]+)>([^<([]+)(?:\[([A-Z]+)\])?\s\(([0-9]{4})\)<\/a>',
-                   ['url', 'title', 'quality', 'year'],
-                   patron_block=r'Ultimi 100 film aggiunti:.*?<\/td>')
-
-
-def last(item):
-    support.log()
-    
-    itemlist = []
-    infoLabels = {}
-    quality = ''
-    PERPAGE = 20
-    page = 1
-    if item.page:
-        page = item.page
-
-    if item.contentType == 'tvshow':
-        matches = support.match(item, r'<a href="([^">]+)".*?>([^(:(|[)]+)([^<]+)<\/a>', '<article class="sequex-post-content.*?</article>', headers)[0]
-    else:
-        matches = support.match(item, r'<a href=([^>]+)>([^(:(|[)]+)([^<]+)<\/a>', r'<strong>Ultimi 100 film Aggiornati:<\/a><\/strong>(.*?)<td>', headers)[0]
-
-    for i, (url, title, info) in enumerate(matches):
-        if (page - 1) * PERPAGE > i: continue
-        if i >= page * PERPAGE: break
-        add = True
-        title = title.rstrip()
-        if item.contentType == 'tvshow':
-            for i in itemlist:
-                if i.url == url: # togliamo i doppi
-                    add = False
-        else:
-            infoLabels['year'] = scrapertoolsV2.find_single_match(info, r'\(([0-9]+)\)')
-            quality = scrapertoolsV2.find_single_match(info, r'\[([A-Z]+)\]')
-
-        if quality:
-            longtitle = title + support.typo(quality,'_ [] color kod')
-        else:
-            longtitle = title
-
-        if add:
-            itemlist.append(
-                    Item(channel=item.channel,
-                        action='findvideos' if item.contentType == 'movie' else 'episodios',
-                        contentType=item.contentType,
-                        title=longtitle,
-                        fulltitle=title,
-                        show=title,
-                        quality=quality,
-                        url=url,
-                        infoLabels=infoLabels
-                        )
-                )
-    support.pagination(itemlist, item, page, PERPAGE)
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
-
-    return itemlist
-
-
+@support.scrape
 def peliculas(item):
-    support.log()
-    if item.contentType == 'movie' or '/serietv/' not in item.url:
-        patron = r'<div class="?card-image"?>.*?<img src="?([^" ]+)"? alt.*?<a href="?([^" >]+)(?:\/|")>([^<[(]+)(?:\[([A-Za-z0-9/-]+)])? (?:\(([0-9]{4})\))?.*?<strong>([^<>&]+).*?DURATA ([0-9]+).*?<br(?: /)?>([^<>]+)'
-        listGroups = ['thumb', 'url', 'title', 'quality', 'year', 'genre', 'duration', 'plot']
+    #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'div class="card-image">.*?<img src="([^ ]+)" alt.*?<a href="([^ >]+)">([^<[(]+)<\/a>.*?<strong><span style="[^"]+">([^<>0-9(]+)\(([0-9]{4}).*?</(?:p|div)>(.*?)</div'
-        listGroups = ['thumb', 'url', 'title', 'genre', 'year', 'plot']
+        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'
 
-    return support.scrape(item, patron_block=[r'<div class="?sequex-page-left"?>(.*?)<aside class="?sequex-page-right"?>',
-                                              '<div class="?card-image"?>.*?(?=<div class="?card-image"?>|<div class="?rating"?>)'],
-                          patron=patron, listGroups=listGroups,
-                          patronNext='<a class="?page-link"? href="?([^>]+)"?><i class="fa fa-angle-right">', blacklist=blacklist, action=action)
+    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):
-    itemlist = []
+    @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
 
-    data = httptools.downloadpage(item.url).data
-    matches = scrapertoolsV2.find_multiple_matches(data,
-                                                   r'(<div class="sp-head[a-z ]*?" title="Espandi">[^<>]*?</div>.*?)<div class="spdiv">\[riduci\]</div>')
+            patron = r'<tr><td>(?P<title>[^<]+)<td><span [^>].+?><a [^>]+href="(?P<url>[^"]+)[^>]+>'
+            sceneTitle = True
+            # debug = True
 
-    for match in matches:
-        support.log(match)
-        blocks = scrapertoolsV2.find_multiple_matches(match, '(?:<p>)(.*?)(?:</p>|<br)')
-        season = scrapertoolsV2.find_single_match(match, r'title="Espandi">.*?STAGIONE\s+\d+([^<>]+)').strip()
+            def itemHook(item):
+                item.serieFolder = True
+                return item
+        return locals()
 
-        for block in blocks:
-            episode = scrapertoolsV2.find_single_match(block, r'([0-9]+(?:&#215;|×)[0-9]+)').strip()
-            seasons_n = scrapertoolsV2.find_single_match(block, r'<strong>STAGIONE\s+\d+([^<>]+)').strip()
+    # 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="?([^" ]+)'))
 
-            if seasons_n:
-                season = seasons_n
+    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
 
-            if not episode: continue
+        for key, value in title_dict.items():
+            itlist.append(value)
 
-            season = re.sub(r'&#8211;|–', "-", season)
-            itemlist.append(
-                Item(channel=item.channel,
-                     action="findvideos",
-                     contentType='episode',
-                     title="[B]" + episode + "[/B] " + season,
-                     fulltitle=episode + " " + season,
-                     show=episode + " " + season,
-                     url=block,
-                     extra=item.extra,
-                     thumbnail=item.thumbnail,
-                     infoLabels=item.infoLabels
-                     ))
+        itlist = sorted(itlist, key=lambda it: (it.contentLanguage, int(it.order)))
 
-    support.videolibrary(itemlist, item)
+        itlist.extend(folderItemlist)
 
-    return itemlist
+        return itlist
+    return locals()
 
 
 def findvideos(item):
-    findhost()
-
+    if item.serieFolder:
+        return support.server(item, data=item.url)
     if item.contentType == "episode":
         return findvid_serie(item)
 
-    def load_links(itemlist, re_txt, color, desc_txt, quality=""):
-        streaming = scrapertoolsV2.find_single_match(data, re_txt).replace('"', '')
-        support.log('STREAMING=', streaming)
-        patron = '<td><a.*?href=(.*?) (?:target|rel)[^>]+>([^<]+)<'
-        matches = re.compile(patron, re.DOTALL).findall(streaming)
+    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(channel=item.channel,
-                     action="play",
-                     title=scrapedtitle,
-                     url=scrapedurl,
-                     server=scrapedtitle,
-                     fulltitle=item.fulltitle,
-                     thumbnail=item.thumbnail,
-                     show=item.show,
-                     quality=quality,
-                     contentType=item.contentType,
-                     folder=False))
+            itemlist.append(item.clone(action="play", title=scrapedtitle, url=scrapedurl, server=scrapedtitle, quality=quality))
 
-    support.log()
+    logger.debug()
 
     itemlist = []
 
     # Carica la pagina
     data = httptools.downloadpage(item.url).data
-    data = re.sub('\n|\t','',data)
-
-    # Extract the quality format
-    patronvideos = '>([^<]+)</strong></div>'
-    matches = re.compile(patronvideos, re.DOTALL).finditer(data)
-    QualityStr = ""
-    for match in matches:
-        QualityStr = scrapertoolsV2.decodeHtmlentities(match.group(1))[6:]
+    data = re.sub('\n|\t', '', data)
 
     # Estrae i contenuti - Streaming
-    load_links(itemlist, '<strong>Streaming:</strong>(.*?)<tableclass=cbtable height=30>', "orange", "Streaming", "SD")
+    load_links(itemlist, '<strong>Streamin?g:</strong>(.*?)cbtable', "Streaming", "SD")
 
     # Estrae i contenuti - Streaming HD
-    load_links(itemlist, '<strong>Streaming HD[^<]+</strong>(.*?)<tableclass=cbtable height=30>', "yellow", "Streaming HD", "HD")
+    load_links(itemlist, '<strong>Streamin?g HD[^<]+</strong>(.*?)cbtable', "Streaming HD", "HD")
 
     # Estrae i contenuti - Streaming 3D
-    load_links(itemlist, '<strong>Streaming 3D[^<]+</strong>(.*?)<tableclass=cbtable height=30>', "pink", "Streaming 3D")
+    load_links(itemlist, '<strong>Streamin?g 3D[^<]+</strong>(.*?)cbtable', "Streaming 3D")
 
-    return support.server(item, itemlist=itemlist)
+    # 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")
@@ -283,94 +231,12 @@ def findvideos(item):
 
 
 def findvid_serie(item):
-    def load_vid_series(html, item, itemlist, blktxt):
-        logger.info('HTML' + html)
-        patron = '<a href="([^"]+)"[^=]+="_blank"[^>]+>(.*?)</a>'
-        # Estrae i contenuti
-        matches = re.compile(patron, re.DOTALL).finditer(html)
-        for match in matches:
-            scrapedurl = match.group(1)
-            scrapedtitle = match.group(2)
-            # title = item.title + " [COLOR blue][" + scrapedtitle + "][/COLOR]"
-            itemlist.append(
-                Item(channel=item.channel,
-                     action="play",
-                     title=scrapedtitle,
-                     url=scrapedurl,
-                     server=scrapedtitle,
-                     fulltitle=item.fulltitle,
-                     show=item.show,
-                     contentType=item.contentType,
-                     folder=False))
+    logger.debug()
+    data = re.sub(r'((?:<p>|<strong>)?[^\d]*\d*(?:&#215;|×)[0-9]+[^<]+)', '', item.other)
 
-    support.log()
-
-    itemlist = []
-    lnkblk = []
-    lnkblkp = []
-
-    data = item.url
-
-    # First blocks of links
-    if data[0:data.find('<a')].find(':') > 0:
-        lnkblk.append(data[data.find(' - ') + 3:data[0:data.find('<a')].find(':') + 1])
-        lnkblkp.append(data.find(' - ') + 3)
-    else:
-        lnkblk.append(' ')
-        lnkblkp.append(data.find('<a'))
-
-    # Find new blocks of links
-    patron = r'<a\s[^>]+>[^<]+</a>([^<]+)'
-    matches = re.compile(patron, re.DOTALL).finditer(data)
-    for match in matches:
-        sep = match.group(1)
-        if sep != ' - ':
-            lnkblk.append(sep)
-
-    i = 0
-    if len(lnkblk) > 1:
-        for lb in lnkblk[1:]:
-            lnkblkp.append(data.find(lb, lnkblkp[i] + len(lnkblk[i])))
-            i = i + 1
-
-    for i in range(0, len(lnkblk)):
-        if i == len(lnkblk) - 1:
-            load_vid_series(data[lnkblkp[i]:], item, itemlist, lnkblk[i])
-        else:
-            load_vid_series(data[lnkblkp[i]:lnkblkp[i + 1]], item, itemlist, lnkblk[i])
-
-    return support.server(item, itemlist=itemlist)
+    return support.server(item, data=data)
 
 
 def play(item):
-    support.log()
-    itemlist = []
-    ### Handling new cb01 wrapper
-    if host[9:] + "/film/" in item.url:
-        iurl = httptools.downloadpage(item.url, only_headers=True, follow_redirects=False).headers.get("location", "")
-        support.log("/film/ wrapper: ", iurl)
-        if iurl:
-            item.url = iurl
-
-    if '/goto/' in item.url:
-        item.url = item.url.split('/goto/')[-1].decode('base64')
-
-    item.url = item.url.replace('http://cineblog01.uno', 'http://k4pp4.pw')
-
-    logger.debug("##############################################################")
-    if "go.php" in item.url:
-        data = httptools.downloadpage(item.url).data
-        if "window.location.href" in data:
-            try:
-                data = scrapertoolsV2.find_single_match(data, 'window.location.href = "([^"]+)";')
-            except IndexError:
-                data = httptools.downloadpage(item.url, only_headers=True, follow_redirects=False).headers.get("location", "")
-            data, c = unshortenit.unwrap_30x_only(data)
-        else:
-            data = scrapertoolsV2.find_single_match(data, r'<a href="([^"]+)".*?class="btn-wrapper">.*?licca.*?</a>')
-        
-        logger.debug("##### play go.php data ##\n%s\n##" % data)
-    else:
-        data = support.swzz_get_url(item)
-
-    return servertools.find_video_items(data=data)
+    logger.debug()
+    return servertools.find_video_items(item, data=item.url)

channels/cinemalibero.json

@@ -2,85 +2,10 @@
 	"id": "cinemalibero",
 	"name": "Cinemalibero",
 	"language": ["ita"],
-	"active": true,
-	"adult": false,
-	"thumbnail": "https://www.cinemalibero.center/wp-content/themes/Cinemalibero%202.0/images/logo02.png",
-	"banner": "https://www.cinemalibero.center/wp-content/themes/Cinemalibero%202.0/images/logo02.png",
-	"categories": ["tvshow", "movie","anime"],
-    "settings": [
-    {
-    "id": "channel_host",
-    "type": "text",
-    "label": "Host del canale",
-    "default": "https://www.cinemalibero.fun/",
-    "enabled": true,
-    "visible": true
-    },
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_series",
-            "type": "bool",
-            "label": "Includi in Novità - Serie TV",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_anime",
-            "type": "bool",
-            "label": "Includi in Novità - Anime",
-            "default": false,
-            "enabled": false,
-            "visible": false
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },		
-        {
-            "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": [ "5", "10", "15", "20" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
+	"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

@@ -1,61 +1,192 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Canale per CinemaLibero - First Version
+# Canale per 'cinemaLibero'
 # ------------------------------------------------------------
+
 import re
 
-from core import scrapertools, servertools, httptools, support
-from core import tmdb
+from core import httptools, support, scrapertools
 from core.item import Item
-from lib import unshortenit
-from platformcode import config
-from platformcode import logger
-from specials import autoplay
-import channelselector
+from core.support import typo
+from platformcode import config, logger
+import sys
 
-# Necessario per Autoplay
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['akstream', 'wstream', 'openload', 'streamango']
-list_quality = ['default']
+from platformcode.logger import debug
+if sys.version_info[0] >= 3:
+    from concurrent import futures
+else:
+    from concurrent_py2 import futures
 
-# Necessario per Verifica Link
-checklinks = config.get_setting('checklinks', 'cinemalibero')
-checklinks_number = config.get_setting('checklinks_number', 'cinemalibero')
-
-__channel__ = "cinemalibero"
-host = config.get_channel_url(__channel__)
+# 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):
-    logger.info('[cinemalibero.py] mainlist')
-    
-    autoplay.init(item.channel, list_servers, list_quality) # Necessario per Autoplay
 
-    # Menu Principale
-    itemlist = []
-    support.menu(itemlist, 'Film bold', 'video', host+'/category/film/')
-    support.menu(itemlist, 'Generi submenu', 'genres', host)
-    support.menu(itemlist, 'Cerca film submenu', 'search', host)
-    support.menu(itemlist, 'Serie TV bold', 'video', host+'/category/serie-tv/', contentType='episode')
-    support.menu(itemlist, 'Anime submenu', 'video', host+'/category/anime-giapponesi/', contentType='episode')
-    support.menu(itemlist, 'Cerca serie submenu', 'search', host, contentType='episode')
-    support.menu(itemlist, 'Sport bold', 'video', host+'/category/sport/')
+    film = ['/category/film/',
+            ('Novità', ['', 'peliculas', 'update']),
+            ('Generi', ['', 'genres'])]
 
-    autoplay.show_option(item.channel, itemlist) # Necessario per Autoplay (Menu Configurazione)
+    tvshow = ['/category/serie-tv/']
 
-    support.channel_config(item, itemlist)
-    
-    return itemlist
+    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.info("[cinemalibero.py] " + item.url + " search " + texto)
+    logger.debug(item.url,texto)
+    texto = texto.replace(' ', '+')
     item.url = host + "/?s=" + texto
+    # item.contentType = 'tv'
+    item.args = 'search'
     try:
-        return video(item)
-    # Continua la ricerca in caso di errore 
+        return peliculas(item)
+    # Continua la ricerca in caso di errore
     except:
         import sys
         for line in sys.exc_info():
@@ -63,264 +194,99 @@ def search(item, texto):
     return []
 
 
-def genres(item):
-    return support.scrape(item, patron_block=r'<div id="bordobar" class="dropdown-menu(.*?)</li>', patron=r'<a class="dropdown-item" href="([^"]+)" title="([A-z]+)"', listGroups=['url', 'title'], action='video')
-
-
-def video(item):
-    logger.info('[cinemalibero.py] video')
+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 []
 
-    if host not in item.url:
-        item.url = host + item.url
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url).data.replace('\n','').replace('\t','')
-    block = scrapertools.find_single_match(data, '<div class="container">.*?class="col-md-12[^"]*?">(.*?)<div class=(?:"container"|"bg-dark ")>')
-
-    # Estrae i contenuti 
-    matches = re.compile(r'<div class="col-lg-3">(.*?)<\/a><\/div>', re.DOTALL).findall(block)
-
-    for match in matches:
-        url = scrapertools.find_single_match(match, r'href="([^"]+)"')
-        long_title = scrapertools.find_single_match(match, r'<div class="titolo">([^<]+)<\/div>')
-        thumb = scrapertools.find_single_match(match, r'url=\((.*?)\)')
-        quality = scrapertools.find_single_match(match, r'<div class="voto">([^<]+)<\/div>')
-        genere = scrapertools.find_single_match(match, r'<div class="genere">([^<]+)<\/div>')
-
-        year = scrapertools.find_single_match(long_title, r'\(([0-9)]+)') or scrapertools.find_single_match(long_title, r'\) ([0-9)]+)')
-        lang = scrapertools.find_single_match(long_title, r'\(([a-zA-Z)]+)')
-        
-        title = re.sub(r'\(.*','',long_title)
-        title = re.sub(r'(?:\(|\))','',title)
-        if genere:
-            genere = ' - [' + genere + ']'
-        if year:
-            long_title = title + ' - ('+ year + ')' + genere
-        if lang:
-            long_title = '[B]' + title + '[/B]' + ' - ('+ lang + ')' + genere
-        else:
-            long_title = '[B]' + title + '[/B]'
-       
-        # Seleziona fra Serie TV e Film
-        if item.contentType == 'movie':
-            tipologia = 'movie'
-            action = 'findvideos'
-        elif item.contentType == 'episode':
-            tipologia = 'tv'
-            action = 'episodios'
-        else:
-            tipologia = 'movie'
-            action = 'select'
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action=action,
-                 contentType=item.contentType,
-                 title=long_title,
-                 fulltitle=title,
-                 quality=quality,
-                 url=url,
-                 thumbnail=thumb,
-                 infoLabels={'year': year},
-                 show=title))
-
-    # Next page
-    next_page = scrapertools.find_single_match(data, '<a class="next page-numbers".*?href="([^"]+)">')
-
-    if next_page != '':
-        itemlist.append(
-            Item(channel=item.channel,
-                 action='video',
-                 title='[B]' + config.get_localized_string(30992) + ' &raquo;[/B]',
-                 url=next_page,
-                 contentType=item.contentType,
-                 thumbnail='http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png'))
-
-    tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
     return itemlist
 
 
-def select(item):
-    data = httptools.downloadpage(item.url, headers=headers).data
-    block = scrapertools.find_single_match(data, r'<div class="col-md-8 bg-white rounded-left p-5"><div>(.*?)<\/div>')
-    if re.findall('rel="category tag">serie', data, re.IGNORECASE):
-        logger.info('select = ### è una serie ###')
-        return episodios(Item(channel=item.channel,
-                              title=item.title,
-                              fulltitle=item.fulltitle,
-                              url=item.url,
-                              extra='serie',
-                              contentType='episode'))
-    elif re.findall('rel="category tag">anime', data, re.IGNORECASE):
-        if re.findall('episodio', block, re.IGNORECASE):
-            logger.info('select = ### è un anime ###')
-            return episodios(Item(channel=item.channel,
-                                title=item.title,
-                                fulltitle=item.fulltitle,
-                                url=item.url,
-                                extra='anime',
-                                contentType='episode'))
+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:
-            logger.info('select = ### è un film ###')
-            return findvideos(Item(channel=item.channel,
-                                    title=item.title,
-                                    fulltitle=item.fulltitle,
-                                    url=item.url,
-                                    contentType='movie'))
+            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:
-        logger.info('select = ### è un film ###')
-        return findvideos(Item(channel=item.channel,
-                              title=item.title,
-                              fulltitle=item.fulltitle,
-                              url=item.url,
-                              contentType='movie'))
-
-
-def findvideos(item): # Questa def. deve sempre essere nominata findvideos
-    logger.info('[cinemalibero.py] findvideos')
-    itemlist = []
-
-    if item.args == 'direct':
-        return servertools.find_video_items(item)
-
-    if item.contentType == 'episode':
-        data = item.url.lower()
-        block = scrapertools.find_single_match(data,r'>streaming.*?<\/strong>*?<\/h2>(.*?)<\/div>')
-        urls = re.findall('<a.*?href="([^"]+)"', block, re.DOTALL)
-    else:
-        data = httptools.downloadpage(item.url, headers=headers).data
-        data = re.sub(r'\n|\t','',data).lower()
-        block = scrapertools.find_single_match(data,r'>streaming.*?<\/strong>(.*?)<strong>')
-        urls = re.findall('<a href="([^"]+)".*?class="external"', block, re.DOTALL)
-    
-    logger.info('URLS'+ str(urls))
-    if urls:
-        data =''
-        for url in urls:
-            url, c = unshortenit.unshorten(url)
-            data += url + '\n'
-                
-    logger.info('DATA'+ data)
-    itemlist = servertools.find_video_items(data=data)
-
-    for videoitem in itemlist:
-        videoitem.title = item.fulltitle + ' - [COLOR limegreen][[/COLOR]'+videoitem.title+' [COLOR limegreen]][/COLOR]'
-        videoitem.fulltitle = item.fulltitle
-        videoitem.thumbnail = item.thumbnail
-        videoitem.show = item.show
-        videoitem.plot = item.plot
-        videoitem.channel = item.channel
-        videoitem.contentType = item.contentType
-
-    # Link Aggiungi alla Libreria
-    if item.contentType != 'episode':
-        if config.get_videolibrary_support() and len(itemlist) > 0 and item.extra != 'findservers':
-            itemlist.append(
-                Item(channel=item.channel, title='[COLOR lightblue][B]Aggiungi alla videoteca[/B][/COLOR]', url=item.url,
-                     action='add_pelicula_to_library', extra='findservers', contentTitle=item.contentTitle))
-
-    # Necessario per filtrare i Link
-    if checklinks:
-        itemlist = servertools.check_list_links(itemlist, checklinks_number)
-
-    # Necessario per  FilterTools
-    # itemlist = filtertools.get_links(itemlist, item, list_language)
-
-    # Necessario per  AutoPlay
-    autoplay.start(itemlist, item)
-    
-    
-    return itemlist
-
-
-def episodios(item): # Questa def. deve sempre essere nominata episodios
-    logger.info('[cinemalibero.py] episodios')
-    itemlist = []
-    extra = ''
-
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url, headers=headers).data
-    block = scrapertools.find_single_match(data, r'<div class="col-md-8 bg-white rounded-left p-5"><div>(.*?)at-below-post')
-    if re.findall('rel="category tag">serie', data, re.IGNORECASE):
-        # logger.info('select = ### è una serie ###')
-        extra='serie'
-    elif re.findall('rel="category tag">anime', data, re.IGNORECASE):
-        if re.findall('episodi', block, re.IGNORECASE):
-            # logger.info('select = ### è un anime ###')
-            extra='anime'
-
-    block = re.sub(r'<h2>.*?<\/h2>','',block)    
-    block = block.replace('<p>','').replace('<p style="text-align: left;">','').replace('–<','<').replace('-<','<').replace('&#8211;<','<').replace('&#8211; <','<').replace('<strong>','<stop><start><strong>')+'<stop>'
-    block = re.sub(r'stagione completa.*?<\/p>','',block,flags=re.IGNORECASE)
-    
-
-    if extra == 'serie':
-        block = block.replace('<br /> <a','<a')
-        matches = re.compile(r'<start>.*?(?:stagione|Stagione)(.*?)<\/(?:strong|span)><\/p>(.*?)<stop>', re.DOTALL).findall(block)
-
-        if not matches:
-            matches = scrapertools.find_multiple_matches(block, r'<a href="([^"]+)"[^>]+>(Episodio [0-9]+)</a>')
-            for scrapedurl, scrapedtitle in matches:
-                scrapedtitle = re.sub(r'Episodio ([0-9]+)', r'Episodio 1x\1', scrapedtitle)
-                itemlist.append(
-                    Item(channel=item.channel,
-                         action="findvideos",
-                         contentType='episode',
-                         title=scrapedtitle,
-                         fulltitle=scrapedtitle,
-                         show=item.fulltitle,
-                         url=scrapedurl,
-                         args='direct'))
-        else:
-            for lang, html in matches:
-                lang = re.sub('<.*?>','',lang)
-                html = html.replace('<br />','\n').replace('</p>', '\n')
-
-                matches = re.compile(r'([^<]+)([^\n]+)\n', re.DOTALL).findall(html)
-                for scrapedtitle, html in matches:
-                    itemlist.append(
-                        Item(channel=item.channel,
-                            action="findvideos",
-                            contentType='episode',
-                            title=scrapedtitle + ' - (' + lang + ')',
-                            fulltitle=scrapedtitle,
-                            show=item.fulltitle,
-                            url=html))
-
-    elif extra == 'anime':
-        block = re.sub(r'<start.*?(?:download:|Download:).*?<stop>','',block)
-        block = re.sub(r'(?:mirror|Mirror)[^<]+<','',block)
-        block = block.replace('<br />','\n').replace('/a></p>','\n')
-        block = re.sub(r'<start.*?(?:download|Download).*?\n','',block)
-        matches = re.compile('<a(.*?)\n', re.DOTALL).findall(block)
-        for html in matches:
-            scrapedtitle = scrapertools.find_single_match(html, r'>(.*?)<\/a>')
-            itemlist.append(
-                Item(channel=item.channel,
-                    action="findvideos",
-                    contentType='episode',
-                    title=scrapedtitle,
-                    fulltitle=scrapedtitle,
-                    show=item.fulltitle,
-                    url=html))
-
-    else:
-        logger.info('select = ### è un film ###')
-        return findvideos(Item(channel=item.channel,
-                               title=item.title,
-                               fulltitle=item.fulltitle,
-                               url=item.url,
-                               show=item.fulltitle,
-                               contentType='movie'))
-    
-    if config.get_videolibrary_support() and len(itemlist) != 0:
-        itemlist.append(
-            Item(channel=item.channel,
-                 title="[COLOR lightblue]%s[/COLOR]" % config.get_localized_string(30161),
-                 url=item.url,
-                 action="add_serie_to_library",
-                 extra="episodios",
-                 show=item.show))
-   
-    return itemlist
+        return total_servers

channels/cinemastreaming.json

@@ -1,71 +0,0 @@
-{
-	"id": "cinemastreaming",
-	"name": "Cinemastreaming",
-	"language": ["ita"],
-	"active": false,
-	"adult": false,
-	"thumbnail": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",
-	"banner": "https://www.telegramitalia.it/wp-content/uploads/2018/02/IMG_20180222_214809_805.jpg",
-	"categories": ["tvshow", "movie"],
-    "settings": [
-        {
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Includi ricerca globale",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_peliculas",
-            "type": "bool",
-            "label": "Includi in Novità - Film",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_series",
-            "type": "bool",
-            "label": "Includi in Novità - Serie TV",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-        {
-            "id": "include_in_newest_italiano",
-            "type": "bool",
-            "label": "Includi in Novità - Italiano",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-            
-        {
-            "id": "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": [ "5", "10", "15", "20" ]
-        },
-        {
-            "id": "filter_languages",
-            "type": "list",
-            "label": "Mostra link in lingua...",
-            "default": 0,
-            "enabled": true,
-            "visible": true,
-            "lvalues": ["Non filtrare","IT"]
-        }
-    ]
-}

channels/cinemastreaming.py

@@ -1,191 +0,0 @@
-# -*- coding: utf-8 -*-
-# ------------------------------------------------------------
-# Canale per cinemastreaming
-# ------------------------------------------------------------
-import re
-
-from core import scrapertools, httptools, scrapertoolsV2, support
-from core.item import Item
-from specials import autoplay
-from platformcode import config
-
-__channel__ = "cinemastreaming"
-host = config.get_channel_url(__channel__)
-IDIOMAS = {'Italiano': 'IT'}
-list_language = IDIOMAS.values()
-list_servers = ['openload', 'streamango']
-list_quality = ['1080p', '1080p 3D', 'SD', 'CAM', 'default']
-
-headers = [['Referer', host]]
-
-
-def mainlist(item):
-    support.log()
-
-    # Menu Principale
-    itemlist = []
-    support.menu(itemlist, 'Film bold', 'peliculas', host + '/film/')
-    support.menu(itemlist, 'Per genere submenu', 'menu', host, args="Film per Genere")
-    support.menu(itemlist, 'Anime bold', 'peliculas', host + '/category/anime/')
-    support.menu(itemlist, 'Serie TV bold', 'peliculas', host + '/serie-tv/', contentType='episode')
-    support.menu(itemlist, 'Ultime Uscite submenu', 'peliculas', host + "/stagioni/", "episode", args='latests')
-    support.menu(itemlist, 'Ultimi Episodi submenu', 'peliculas_latest_ep', host + "/episodi/", "episode", args='lateste')
-    support.menu(itemlist, '[COLOR blue]Cerca...[/COLOR]', 'search')
-
-    autoplay.init(item.channel, list_servers, list_quality)
-    autoplay.show_option(item.channel, itemlist)
-
-    return itemlist
-
-
-def peliculas(item):
-    support.log()
-    list_groups = ["url", "thumb", "title", "year", "rating", "duration"]
-
-    patron = r'<article.*?"TPost C".*?href="([^"]+)".*?img.*?src="([^"]+)".*?<h3.*?>([^<]+).*?Year">'
-
-    if item.args == "latests":
-        patron += r'([^<]+)'
-    else:
-        patron += r'(\d{4}).*?AAIco-star.*?>([^<]+).*?AAIco-access_time">([^<]+).*?Qlty'
-
-    patron_next = r'page-numbers current.*?href="([^"]+)"'
-
-    if item.contentType == "movie":
-        patron += r'\">([^<]+)'
-        list_groups.append("quality")
-
-    action = "findvideos" if item.contentType == "movie" else "episodios"
-
-    return support.scrape(item, patron, list_groups, patronNext=patron_next, action=action)
-
-
-def peliculas_latest_ep(item):
-
-    patron = r'<article.*?"TPost C".*?href="([^"]+)".*?img.*?src="([^"]+)"'
-    patron += r'.*?class="ClB">([^<]+)<\/span>([^<]+).*?<h3.*?>([^<]+)'
-
-    data = httptools.downloadpage(item.url).data
-
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    itemlist = []
-    for scrapedurl, scrapedthumbnail, scrapednum, scrapedep, scrapedtitle in matches:
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="findvideos",
-                 contentType=item.contentType,
-                 title="[B]" + scrapednum + "[/B]" + scrapedep + " - " + scrapedtitle,
-                 fulltitle=scrapedep + " " + scrapedtitle,
-                 show=scrapedep + " " + scrapedtitle,
-                 url=scrapedurl,
-                 extra=item.extra,
-                 thumbnail="http:" + scrapedthumbnail,
-                 infoLabels=item.infoLabels
-                 ))
-
-    support.nextPage(itemlist, item, data, r'page-numbers current.*?href="([^"]+)"')
-
-    return itemlist
-
-
-def peliculas_menu(item):
-    itemlist = peliculas(item)
-    return itemlist[:-1]
-
-
-def episodios(item):
-    patron = r'<td class="MvTbTtl"><a href="([^"]+)">(.*?)<\/a>.*?>\d{4}<'
-    list_groups = ["url", "title", "year"]
-
-    itemlist = support.scrape(item, patron, list_groups)
-
-    for itm in itemlist:
-        fixedtitle = scrapertools.get_season_and_episode(itm.url)
-        itm.title = fixedtitle + " - " + itm.title
-        itm.fulltitle = fixedtitle + " - " + itm.fulltitle
-
-    return itemlist
-
-
-def menu(item):
-    patron_block = r'<ul class="sub-menu">.*?</ul>'
-    patron = r'menu-category-list"><a href="([^"]+)">([^<]+)<'
-    list_groups = ["url", "title"]
-
-    return support.scrape(item, patron, list_groups, blacklist="Anime", action="peliculas_menu", patron_block=patron_block)
-
-
-def search(item, texto):
-    support.log("s=", texto)
-    item.url = host + "/?s=" + texto
-    try:
-        return peliculas(item)
-    # Continua la ricerca in caso di errore
-    except Exception, e:
-        import traceback
-        traceback.print_stack()
-        support.log(str(e))
-        return []
-
-
-def newest(categoria):
-    support.log("newest" + categoria)
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == "series":
-            item.url = host + "/episodi/"
-            item.action = "peliculas"
-            item.args = "lateste"
-            item.contentType = "episode"
-            itemlist = peliculas(item)
-
-            if itemlist[-1].action == "peliculas":
-                itemlist.pop()
-
-    # Continua la ricerca in caso di errore
-    except Exception, e:
-        import traceback
-        traceback.print_stack()
-        support.log(str(e))
-        return []
-
-    return itemlist
-
-
-def findvideos(item):
-
-    if item.quality.lower() in ["ended", "canceled", "returning series"]:
-        return episodios(item)
-
-    itemlist = []
-    data = scrapertoolsV2.decodeHtmlentities(httptools.downloadpage(item.url).data)
-    btns = re.compile(r'data-tplayernv="Opt.*?><span>([^<]+)</span><span>([^<]+)</span>', re.DOTALL).findall(data)
-    matches = re.compile(r'<iframe.*?src="([^"]+trembed=[^"]+)', re.DOTALL).findall(data)
-    for i, scrapedurl in enumerate(matches):
-
-        scrapedurl = scrapertoolsV2.decodeHtmlentities(scrapedurl)
-        patron = r'<iframe.*?src="([^"]+)"'
-        link_data = httptools.downloadpage(scrapedurl).data
-        url = scrapertoolsV2.find_single_match(link_data, patron)
-
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="play",
-                 contentType=item.contentType,
-                 title="[B]" + btns[i][0] + "[/B] - " + btns[i][1],
-                 fulltitle=btns[i][0] + " " + btns[i][1],
-                 show=btns[i][0] + " " + btns[i][1],
-                 url=url,
-                 extra=item.extra,
-                 infoLabels=item.infoLabels,
-                 server=btns[i][0],
-                 contentQuality=btns[i][1].replace('Italiano - ', ''),
-                 ))
-
-    if item.contentType == "movie":
-        support.videolibrary(itemlist, item)
-    autoplay.start(itemlist, item)
-
-    return itemlist
-

channels/cinetecadibologna.json

@@ -1,36 +1,11 @@
 {
 	"id": "cinetecadibologna",
-	"name": "Cinetecadibologna",
+	"name": "Cineteca di Bologna",
 	"language": ["ita"],
 	"active": true,
-	"adult": false,
-	"thumbnail": "http://cinestore.cinetecadibologna.it/pics/logo.gif",
-	"banner": "http://cinestore.cinetecadibologna.it/pics/logo.gif",
+	"thumbnail": "cinetecadibologna.png",
+	"banner": "cinetecadibologna.png",
 	"categories": ["documentary"],
-	"settings": [
-		{
-            "id": "include_in_global_search",
-            "type": "bool",
-            "label": "Incluir en busqueda global",
-            "default": false,
-            "enabled": false,
-            "visible": false
-		},
-		{
-            "id": "include_in_newest_documentales",
-            "type": "bool",
-            "label": "Includi in Novità - Documentari",
-            "default": true,
-            "enabled": true,
-            "visible": true
-        },
-		{
-			"id": "include_in_newest_italiano",
-			"type": "bool",
-			"label": "Includi in Novità - Italiano",
-			"default": true,
-			"enabled": true,
-			"visible": true
-		}
-    ]
+	"not_active":["include_in_newest_peliculas", "include_in_newest_series", "include_in_newest_anime", "include_in_global_search"],
+	"settings": []
 }

channels/cinetecadibologna.py

@@ -1,155 +1,74 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------
-# Ringraziamo Icarus crew
 # Canale per cinetecadibologna
 # ------------------------------------------------------------
-
-import re
-
-import urlparse
-
-from core import httptools, scrapertools
 from core.item import Item
-from platformcode import logger, config
 
-host = "http://cinestore.cinetecadibologna.it"
+from core import support
+
+host = support.config.get_channel_url()
+
 
 headers = [['Referer', host]]
-
+@support.menu
 def mainlist(item):
-    logger.info("kod.cinetecadibologna mainlist")
-    itemlist = [Item(channel=item.channel, 
-                     title="[COLOR azure]Elenco Film - Cineteca di Bologna[/COLOR]", 
-                     action="peliculas",
-                     url="%s/video/alfabetico_completo" % host,
-                     thumbnail="http://cinestore.cinetecadibologna.it/pics/logo.gif"),
-                Item(channel=item.channel,
-                     title="[COLOR azure]Epoche - Cineteca di Bologna[/COLOR]",
-                     action="epoche",
-                     url="%s/video/epoche" % host,
-                     thumbnail="http://cinestore.cinetecadibologna.it/pics/logo.gif"),
-                Item(channel=item.channel,
-                     title="[COLOR azure]Percorsi Tematici - Cineteca di Bologna[/COLOR]",
-                     action="percorsi",
-                     url="%s/video/percorsi" % host,
-                     thumbnail="http://cinestore.cinetecadibologna.it/pics/logo.gif")]
-
-    return itemlist
+    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):
-    logger.info("kod.cinetecadibologna peliculas")
-    itemlist = []
+    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()
 
-    # Carica la pagina 
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    # Estrae i contenuti 
-    patron = '<img src="([^"]+)"[^>]+>\s*[^>]+>\s*<div[^>]+>\s*<div[^>]+>[^>]+>\s*<a href="([^"]+)"[^>]+>(.*?)<'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for scrapedthumbnail, scrapedurl, scrapedtitle in matches:
-        scrapedtitle = scrapertools.decodeHtmlentities(scrapedtitle)
-        scrapedthumbnail = host + scrapedthumbnail
-        scrapedurl = host + scrapedurl
-        if not "/video/" in scrapedurl:
-            continue
-        html = scrapertools.cache_page(scrapedurl)
-        start = html.find("Sinossi:")
-        end = html.find('<div class="sx_col">', start)
-        scrapedplot = html[start:end]
-        scrapedplot = re.sub(r'<[^>]*>', '', scrapedplot)
-        scrapedplot = scrapertools.decodeHtmlentities(scrapedplot)
-        itemlist.append(Item(channel=item.channel, action="findvideos", fulltitle=scrapedtitle, show=scrapedtitle,
-                             title=scrapedtitle, url=scrapedurl, thumbnail=scrapedthumbnail, plot=scrapedplot,
-                             folder=True))
-
-    # Paginazione 
-    patronvideos = '<div class="footerList clearfix">\s*<div class="sx">\s*[^>]+>[^g]+gina[^>]+>\s*[^>]+>\s*<div class="dx">\s*<a href="(.*?)">pagina suc'
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-
-    if len(matches) > 0:
-        scrapedurl = urlparse.urljoin(item.url, matches[0])
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR lightgreen]" + config.get_localized_string(30992) + "[/COLOR]",
-                 url= scrapedurl,
-                 thumbnail="http://2.bp.blogspot.com/-fE9tzwmjaeQ/UcM2apxDtjI/AAAAAAAAeeg/WKSGM2TADLM/s1600/pager+old.png",
-                 folder=True))
-
-    return itemlist
-
-def epoche(item):
-    logger.info("kod.cinetecadibologna categorias")
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    # Narrow search by selecting only the combo
-    bloque = scrapertools.find_single_match(data, '<h1 class="pagetitle">Epoche</h1>(.*?)</ul>')
-
-    # The categories are the options for the combo
-    patron = '<a href="([^"]+)">(.*?)<'
-    matches = re.compile(patron, re.DOTALL).findall(bloque)
-
-    for scrapedurl, scrapedtitle in matches:
-        scrapedurl = host + scrapedurl
-        scrapedplot = ""
-        if scrapedtitle.startswith(("'")):
-           scrapedtitle = scrapedtitle.replace("'", "Anni '")
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail="http://www.cinetecadibologna.it/pics/cinema-ritrovato-alcinema.png",
-                 plot=scrapedplot))
-
-    return itemlist
-
-def percorsi(item):
-    logger.info("kod.cinetecadibologna categorias")
-    itemlist = []
-
-    data = httptools.downloadpage(item.url, headers=headers).data
-
-    patron = '<div class="cover_percorso">\s*<a href="([^"]+)">\s*<img src="([^"]+)"[^>]+>\s*[^>]+>(.*?)<'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches:
-        scrapedurl = host + scrapedurl
-        scrapedplot = ""
-        scrapedthumbnail = host + scrapedthumbnail
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="peliculas",
-                 title="[COLOR azure]" + scrapedtitle + "[/COLOR]",
-                 url=scrapedurl,
-                 thumbnail=scrapedthumbnail,
-                 plot=scrapedplot))
-
-    return itemlist
 
 def findvideos(item):
-    logger.info("kod.cinetecadibologna findvideos")
+    support.info()
     itemlist = []
 
-    data = httptools.downloadpage(item.url, headers=headers).data
+    matches = support.match(item, patron=r'filename: "(.*?)"').matches
 
-    patron = 'filename: "(.*?)"'
-    matches = re.compile(patron, re.DOTALL).findall(data)
+    for url in matches:
+        itemlist.append(item.clone(action="play", title=support.config.get_localized_string(30137), server='directo', url=host + url))
 
-    for video in matches:
-        video = host + video
-        itemlist.append(
-            Item(
-                channel=item.channel,
-                action="play",
-                title=item.title + " [[COLOR orange]Diretto[/COLOR]]",
-                url=video,
-                folder=False))
-
-    return itemlist
+    return support.server(item, itemlist=itemlist)
 

channels/cinetemagay.json

@@ -1,12 +0,0 @@
-{
-  "id": "cinetemagay",
-  "name": "Cinetemagay",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "cinetemagay.png",
-  "banner": "cinetemagay.png",
-  "categories": [
-    "adult"
-  ]
-}

channels/cinetemagay.py

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import re
-
-from core import httptools
-from core import servertools
-from core.item import Item
-from platformcode import config, logger
-
-IMAGES_PATH = os.path.join(config.get_runtime_path(), 'resources', 'images', 'cinetemagay')
-
-
-def strip_tags(value):
-    return re.sub(r'<[^>]*?>', '', value)
-
-
-def mainlist(item):
-    logger.info()
-
-    itemlist = []
-    itemlist.append(Item(channel=item.channel, action="lista", title="Cine gay latinoamericano",
-                         url="http://cinegaylatinoamericano.blogspot.com.es/feeds/posts/default/?max-results=100&start-index=1",
-                         thumbnail="http://www.americaeconomia.com/sites/default/files/imagecache/foto_nota/homosexual1.jpg"))
-    itemlist.append(Item(channel=item.channel, action="lista", title="Cine y cortos gay",
-                         url="http://cineycortosgay.blogspot.com.es/feeds/posts/default/?max-results=100&start-index=1",
-                         thumbnail="http://www.elmolar.org/wp-content/uploads/2015/05/cortometraje.jpg"))
-    itemlist.append(Item(channel=item.channel, action="lista", title="Cine gay online (México)",
-                         url="http://cinegayonlinemexico.blogspot.com.es/feeds/posts/default/?max-results=100&start-index=1",
-                         thumbnail="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTmmqL6tS2Ced1VoxlGQT0q-ibPEz1DCV3E1waHFDI5KT0pg1lJ"))
-    itemlist.append(Item(channel=item.channel, action="lista", title="Sentido gay",
-                         url="http://www.sentidogay.blogspot.com.es//feeds/posts/default/?max-results=100&start-index=1",
-                         thumbnail="http://1.bp.blogspot.com/-epOPgDD_MQw/VPGZGQOou1I/AAAAAAAAAkI/lC25GrukDuo/s1048/SentidoGay.jpg"))
-    itemlist.append(Item(channel=item.channel, action="lista", title="PGPA",
-                         url="http://pgpa.blogspot.com.es/feeds/posts/default/?max-results=100&start-index=1",
-                         thumbnail="http://themes.googleusercontent.com/image?id=0BwVBOzw_-hbMNTRlZjk2YWMtYTVlMC00ZjZjLWI3OWEtMWEzZDEzYWVjZmQ4"))
-
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-
-    # Descarga la pagina
-    data = httptools.downloadpage(item.url).data
-
-    # Extrae las entradas (carpetas)
-    patronvideos = '&lt;img .*?src=&quot;(.*?)&quot;'
-    patronvideos += "(.*?)<link rel='alternate' type='text/html' href='([^']+)' title='([^']+)'.*?>"
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-
-    for match in matches:
-        scrapedtitle = match[3]
-        scrapedtitle = scrapedtitle.replace("&apos;", "'")
-        scrapedtitle = scrapedtitle.replace("&quot;", "'")
-        scrapedtitle = scrapedtitle.replace("&amp;amp;", "'")
-        scrapedtitle = scrapedtitle.replace("&amp;#39;", "'")
-        scrapedurl = match[2]
-        scrapedthumbnail = match[0]
-        imagen = ""
-        scrapedplot = match[1]
-        tipo = match[1]
-        logger.debug("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
-        scrapedplot = "<" + scrapedplot
-        scrapedplot = scrapedplot.replace("&gt;", ">")
-        scrapedplot = scrapedplot.replace("&lt;", "<")
-        scrapedplot = scrapedplot.replace("</div>", "\n")
-        scrapedplot = scrapedplot.replace("<br />", "\n")
-        scrapedplot = scrapedplot.replace("&amp;", "")
-        scrapedplot = scrapedplot.replace("nbsp;", "")
-        scrapedplot = strip_tags(scrapedplot)
-        itemlist.append(
-            Item(channel=item.channel, action="detail", title=scrapedtitle, url=scrapedurl, thumbnail=scrapedthumbnail,
-                 plot=scrapedurl + scrapedplot, folder=True))
-
-    variable = item.url.split("index=")[1]
-    variable = int(variable)
-    variable += 100
-    variable = str(variable)
-    variable_url = item.url.split("index=")[0]
-    url_nueva = variable_url + "index=" + variable
-    itemlist.append(
-        Item(channel=item.channel, action="lista", title="Ir a la página siguiente (desde " + variable + ")",
-             url=url_nueva, thumbnail="", plot="Pasar a la página siguiente (en grupos de 100)\n\n" + url_nueva))
-
-    return itemlist
-
-
-def detail(item):
-    logger.info()
-    itemlist = []
-
-    # Descarga la pagina
-    data = httptools.downloadpage(item.url).data
-
-    data = data.replace("%3A", ":")
-    data = data.replace("%2F", "/")
-    data = data.replace("%3D", "=")
-    data = data.replace("%3", "?")
-    data = data.replace("%26", "&")
-    descripcion = ""
-    plot = ""
-    patrondescrip = 'SINOPSIS:(.*?)'
-    matches = re.compile(patrondescrip, re.DOTALL).findall(data)
-    if len(matches) > 0:
-        descripcion = matches[0]
-        descripcion = descripcion.replace("&nbsp;", "")
-        descripcion = descripcion.replace("<br/>", "")
-        descripcion = descripcion.replace("\r", "")
-        descripcion = descripcion.replace("\n", " ")
-        descripcion = descripcion.replace("\t", " ")
-        descripcion = re.sub("<[^>]+>", " ", descripcion)
-        descripcion = descripcion
-        try:
-            plot = unicode(descripcion, "utf-8").encode("iso-8859-1")
-        except:
-            plot = descripcion
-
-    # Busca los enlaces a los videos de  servidores
-    video_itemlist = servertools.find_video_items(data=data)
-    for video_item in video_itemlist:
-        itemlist.append(Item(channel=item.channel, action="play", server=video_item.server,
-                             title=item.title + "  " + video_item.title, url=video_item.url, thumbnail=item.thumbnail,
-                             plot=video_item.url, folder=False))
-
-    return itemlist

channels/cliphunter.json

@@ -1,15 +0,0 @@
-{
-  "id": "cliphunter",
-  "name": "cliphunter",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://www.cliphunter.com/gfx/new/logo.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-
-  ]
-}

channels/cliphunter.py

@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host = 'https://www.cliphunter.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Nuevas" , action="lista", url=host + "/categories/All"))
-    itemlist.append( Item(channel=item.channel, title="Popular" , action="lista", url=host + "/popular/ratings/yesterday"))
-    itemlist.append( Item(channel=item.channel, title="Pornstars" , action="catalogo", url=host + "/pornstars/"))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host + "/categories/"))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/search/%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def catalogo(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron  = '<a href="([^"]+)">\s*<img src=\'([^\']+)\'/>.*?<span>([^"]+)</span>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedthumbnail,scrapedtitle in matches:
-        scrapedplot = ""
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl) + "/movies"
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail , plot=scrapedplot) )
-    next_page = scrapertools.find_single_match(data,'<li class="arrow"><a rel="next" href="([^"]+)">&raquo;</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append( Item(channel=item.channel, action="catalogo", title="Página Siguiente >>", text_color="blue",
-                               url=next_page) )
-    return itemlist
-
-
-def categorias(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron  = '<a href="([^"]+)" title="([^"]+)">.*?<img src="([^"]+)"/>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle,scrapedthumbnail in matches:
-        scrapedplot = ""
-        scrapedtitle = scrapedtitle
-        scrapedurl = urlparse.urljoin(item.url,scrapedurl)
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              fanart=scrapedthumbnail, thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|&nbsp;|<br>", "", data)
-    patron  = '<img class=".*?" src="([^"]+)".*?<div class="tr">(.*?)</div>.*?<a href="([^"]+)\s*" class="vttl.*?">(.*?)</a>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedthumbnail,scrapedtime,scrapedurl,scrapedtitle  in matches:
-        url = urlparse.urljoin(item.url,scrapedurl)
-        title = "[COLOR yellow]" + scrapedtime + "[/COLOR] " + scrapedtitle
-        thumbnail = scrapedthumbnail
-        plot = ""
-        year = ""
-        itemlist.append( Item(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail, plot=plot,
-                              fanart=thumbnail, contentTitle = title, infoLabels={'year':year} ))
-    next_page = scrapertools.find_single_match(data,'<li class="arrow"><a rel="next" href="([^"]+)">&raquo;</a>')
-    if next_page!="":
-        next_page = urlparse.urljoin(item.url,next_page)
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '"url"\:"(.*?)"'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for scrapedurl  in matches:
-        scrapedurl = scrapedurl.replace("\/", "/")
-        title = scrapedurl
-    itemlist.append(Item(channel=item.channel, action="play", title=item.title, fulltitle=item.fulltitle, url=scrapedurl,
-                         thumbnail=item.thumbnail, plot=item.plot, show=item.title, server="directo"))
-    return itemlist
-

channels/coomelonitas.json

@@ -1,15 +0,0 @@
-{
-  "id": "coomelonitas",
-  "name": "Coomelonitas",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "http://www.coomelonitas.com/wp-content/themes/3xTheme/images/logo.png",
-  "banner": "",
-  "categories": [
-    "adult"
-  ],
-  "settings": [
-
-  ]
-}

channels/coomelonitas.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-#------------------------------------------------------------
-import re
-
-from core import httptools
-from core import scrapertools
-from core.item import Item
-from platformcode import logger
-from platformcode import config
-
-host ='http://www.coomelonitas.com'
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append( Item(channel=item.channel, title="Peliculas" , action="lista", url=host))
-    itemlist.append( Item(channel=item.channel, title="Categorias" , action="categorias", url=host))
-    itemlist.append( Item(channel=item.channel, title="Buscar", action="search"))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host+ "/?s=%s" % texto
-    try:
-        return lista(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def categorias(item):
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '<li class="cat-item cat-item-\d+"><a href="([^"]+)">([^"]+)</a>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for scrapedurl,scrapedtitle in matches:
-        scrapedplot = ""
-        scrapedthumbnail = ""
-        itemlist.append( Item(channel=item.channel, action="lista", title=scrapedtitle, url=scrapedurl,
-                              thumbnail=scrapedthumbnail, plot=scrapedplot) )
-    return itemlist
-
-
-def lista(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    patron  = '<div class="all"(.*?)</div>'
-    matches = re.compile(patron,re.DOTALL).findall(data)
-    for match in matches:
-        title = scrapertools.find_single_match(match,'title="([^"]+)"')
-        url = scrapertools.find_single_match(match,'<a href="([^"]+)"')
-        plot = scrapertools.find_single_match(match,'<p class="summary">(.*?)</p>')
-        thumbnail = scrapertools.find_single_match(match,'<img src="([^"]+)"')
-        itemlist.append( Item(channel=item.channel, action="findvideos", title=title, fulltitle=title, url=url,
-                              fanart=thumbnail, thumbnail=thumbnail, plot=plot, viewmode="movie") )
-    next_page = scrapertools.find_single_match(data,'<a href="([^"]+)" class="siguiente">')
-    if next_page!="":
-        itemlist.append(item.clone(action="lista", title="Página Siguiente >>", text_color="blue", url=next_page) )
-    return itemlist
-

channels/cumlouder.json

@@ -1,12 +0,0 @@
-{
-  "id": "cumlouder",
-  "name": "Cumlouder",
-  "active": true,
-  "adult": true,
-  "language": ["*"],
-  "thumbnail": "cumlouder.png",
-  "banner": "cumlouder.png",
-  "categories": [
-    "adult"
-  ]
-}