Como descargar automaticamente a túa serie favorita

Noutro post, falamos Descargador de episodios Torrent (TED), un excelente programa escrito en Java que nos permite engadir as nosas series favoritas e descargalas automaticamente a medida que saen novos capítulos. O método descrito nesta publicación é unha alternativa ao TED, que moitos de vostedes probablemente atoparán de interese..

O método consiste en crear unha tarefa programada que executa un script Python cada certo tempo. Este script descarga os torrents a través de RSS. Moitos sitios de descarga de torrent permiten esta opción, sendo a máis popular ezRSS. A vantaxe de usar RSS para descargar torrents é que permite "subscribirse" e descargar os torrents da súa serie favorita a medida que van aparecendo novos capítulos. Igual que cando te subscribes a un blog ou a unha fonte de noticias.

Os pasos a seguir

1.- Instala o paquete python-beautifulsoup.

sudo apt-get install python-beautifulsoup

2.- Abre o teu editor de texto favorito. Copie o seguinte código nel e garde o ficheiro co seguinte nome: ~ / bin / tormon.py

#! / usr / bin / env python

importar urllib2, urlparse
desde urllib2 importar HTTPError, URLError
desde BeautifulSoup importar BeautifulSoup
importalo
importar optparse

__usage __ = ""
tormon.py -O ~ / test / tormon -u "http: //rss.feed"
'' '

clase principal (obxecto):
    '' '
    tormon comproba un feed rss por novos torrentes. Cando atopa un novo .torrent, to
    descárgao nun directorio de saída especificado, onde (presuntamente) un control
    O programa torrent descargará o ficheiro correspondente.    
    '' '
    def parse_options (auto):
        usage = 'uso:% prog [opcións]' + __ uso__
        analizador = optparse.OptionParser (uso = uso)
        parser.add_option (
            '-O', '--out_dirección_de_output', dest = 'dir__output', 
            help = 'directorio no que se gardan novos torrents', 
            metavar = 'DIR')
        parser.add_option (
            '-f', '--filetype', dest = 'filetype',
            action = 'engadir',
            predeterminado = [],
            help = 'tipos de ficheiros admisibles', 
            metavar = 'TIPO')
        parser.add_option (
            '-d', '--downloaded_torrents', dest = 'downloaded_torrents',
            default = os.path.expanduser ('~ / .downloaded_torrents'),
            help = 'rexistro de torrentes xa descargados', 
            metavar = 'FICHEIRO')
        parser.add_option (
            '-e', '--error_log', dest = 'error_log',
            help = 'Non se puido descargar o rexistro de torrents', 
            metavar = 'FICHEIRO')
        parser.add_option (
            '-b', '--batch', dest = 'lote',
            help = 'ficheiro que contén a lista de URL do feed RSS', 
            metavar = 'FICHEIRO') 
        parser.add_option (
            '-u', '--url', dest = 'url',
            action = 'engadir',
            predeterminado = [],
            help = 'url do feed rss', 
            metavar = 'URL')
        parser.add_option (
            '-m', '- mark_all_downloaded', dest = 'mark_all_downloaded',
            action = 'store_true', 
            predeterminado = Falso,
            help = "marcar todos os torrentes como xa descargados")
        parser.add_option (
            '-M', '- match_by_filename', dest = 'match_by_filename',
            action = 'store_true', 
            predeterminado = Falso,
            help = "recoñecer os ficheiros descargados por nome de ficheiro, non por URL. A coincidencia por URL é o predeterminado.")        
        (self.opt, args) = parser.parse_args ()
        se self.opt.batch:
            para liña en aberto (self.opt.batch, 'r'):
                liña = liña.strip ()
                se liña e non liña.startswith ('#'):
                    self.opt.url.append (liña)
        se non self.opt.output_dir:
            self.opt.output_dir = os.path.expanduser ('~ / Desktop')
        se non self.opt.filetype:
            self.opt.filetype = ['. torrent'] se non self.opt.error_log:
            self.opt.error_log = self.opt.downloaded_torrents + '. erros'
        tentar:
            os.makedirs (self.opt.output_dir)
        agás OSError:
            se non os.path.exists (self.opt.output_dir):
                print ('o tormón fallou ao crear o directorio% s'% self.opt.output_dir)
                saír (1)
    def load_list_of_already_downloaded_torrents (auto):
        tentar:
            self.downloaded = open (self.opt.downloaded_torrents, 'r'). read (). split ()
        agás IOError:
            self.downloaded = [] proba:
            self.errors = open (self.opt.error_log, 'r'). read (). split ()
        agás IOError:
            self.errors = [] def update_downloaded (auto, url):
        self.downloaded.append (url)
        tentar:
            self.errors.remove (url)
        excepto ValueError:
            pasar        
    def_torrent_torrent (auto, url):
        tentar:
            calcetín = urllib2.urlopen (url)
        excepto (HTTPError, URLError):
            # print ('tormon fallou ao descargar% s'% url)
            se a URL non está en self.errors:
                self.errors.append (url)
        senón:
            nome de ficheiro = self.url2 nome de ficheiro (url)
            target_file = os.path.join (self.opt.output_dir, nome de ficheiro)
            print ('Descargando% s'% target_file)
            content = sock.read ()
            sock.close ()
            fh = aberto (ficheiro_destino, 'w')
            fh.write (contido)
            fh.close ()
            self.update_downloaded (url)
    def url2filename (auto, url):
        devolver os.path.basename (urlparse.urlparse (url) [2])
    def has_been_downloaded (auto, url):
        se self.opt.match_by_filename:
            nome de ficheiro = self.url2 nome de ficheiro (url)
            return (nome de ficheiro en [self.url2filename (ligazón) para ligazón en self.downloaded])
        senón:
            retorno (url en self.downloaded)
    def parse_rss_feed (auto):
        para url en self.opt.url:
            print ('RSS feed:% s'% url)
            tentar:
                calcetín = urllib2.urlopen (url)
            excepto (HTTPError, URLError):
                print ('o tormón fallou ao descargar% s'% url)
            senón:
                content = sock.read ()
                sock.close ()
                sopa = BeautifulSoup (contido)
                links = ([link.nextSibling for link in soup.findAll ('link')] +
                       [ligazón ['href'] para ligazón en soup.findAll ('a')] +
                       [ligazón ['url'] para ligazón en soup.findAll ('media: content')])
                para ligazón en ligazóns:
                    if (calquera ([ligazón.lower (). endswith (end))
                             por rematar en self.opt.filetype])
                        e non self.has_been_downloaded (ligazón)):
                        se self.opt.mark_all_downloaded:
                            print ("Marcando% s como ligazón% descargada")
                            self.update_downloaded (ligazón)
                        senón:
                            self.download_torrent (ligazón)
    def save_list_of_already_downloaded_torrents (auto):
        fh = aberto (self.opt.downloaded_torrents, 'w')
        fh.write ('n'.join (auto.descargado))
        fh.close ()
        fh = aberto (self.opt.error_log, 'w')
        fh.write ('n'.join (auto.errores))
        fh.close ()
    __init __ (auto):
        self.parse_options ()        
        self.load_list_of_already_downloaded_torrents ()
        tentar:
            self.parse_rss_feed ()
        excepto KeyboardInterrupt:
            pasar
        finalmente:
            self.save_list_of_already_downloaded_torrents ()
se __nome __ == '__ principal__':
    Principal () 

3.- Concédelle permisos de execución.

chmod + x ~ / bin / tormon.py

4.- Comprobe que todo funciona ben.

tormon.py -O ~ / torrents / -u "http: //rss.feed"

Onde di ~ / torrents /, ten que substituílo polo camiño onde desexa gardar os torrents descargados. Ten en conta que vai haber moitos ficheiros .torrent.

Onde di "http: //rss.feed", tes que substituílo pola URL do feed RSS da túa serie favorita. Como conseguilo? Ben, no caso de que queiras usar ezRSS, Fun á páxina principal e escribín o nome da serie. Aparecerá unha enorme lista cos resultados. No caso de que queira refinar a súa busca (data de filtrado, calidade ou persoa que arrincou o vídeo), pode facelo guiando os exemplos claramente publicados nesa páxina. Unha vez que teña os resultados que busca, faga clic co botón dereito na ligazón que di Feed RSS baseado na busca que aparece xunto ao botón laranxa característico das fontes RSS. Copia a ligazón e pégaa substituíndo a http://rss.feed do exemplo.

Algúns datos adicionais a ter en conta:

• Se omite o parámetro -O, os ficheiros .torrent descargaranse no escritorio.
• Se executas o mesmo comando inmediatamente despois, non debería descargar ningún torrent novo, a non ser que se engada un novo torrent á fonte RSS.
• Este comando crea o cartafol onde se gardarán os torrents se non existe.
• Unha lista das URL dos torrentes descargados con éxito gardarase en ~ / .downloaded_torrents.
• Para supervisar máis de 1 fonte RSS, pode usar o parámetro -u. Exemplo: tormon.py -u "http: //rss.feed1" -u "http: //rss.feed2"

5.- Se todo funciona ben, pode engadir o script como unha tarefa programada en crontab.

crontab -e

Este comando abrirá un editor de texto.

Pega o seguinte código para que estea ao comezo do ficheiro:

PATH = / sbin: / bin: / usr / sbin: / usr / bin: / home / USER / bin
MAILTO = USUARIO

Cambio USUARIO polo seu nome de usuario.

Pega o seguinte código nalgún lugar debaixo CAMIÑO = ...

* / 15 * * * * tormon.py -u "http: //rss.feed"

Isto executarase o script cada 15 minutos. Por suposto, podes cambialo para que se adapte ás túas necesidades. Cando se trata de series de televisión, pode ser acertado executalas unha vez por semana. Non esquezas ler a nosa publicación anterior na que te explicamos paso a paso como engadir tarefas a crontab.

Para executalo todos os domingos ás 10 da mañá:

00 10 * * 0 tormon.py -u "http: //rss.feed"

Para rematar, asegúrese de que hai unha liña en branco ao final do ficheiro crontab. Non sei por que, pero é un requisito crontab para que todo funcione ben.

Garda o ficheiro e sae do editor de texto.

Nota: no caso de que teña instalado un axente de transferencia de correo electrónico, como exim4, a liña MAILTO = USER indicará a crontab que lle envíe os resultados da execución de tormon.py nun correo electrónico.