Gerando periódicos para kindle a partir de RSS ou Atom feeds

Alguns meses atrás eu comprei um kindle paperwhite pela internet. Como a maioria dos usuários eu utilizo o Calibre para gerenciar minha biblioteca e também para fazer download notícias distribuídas em rss ou atom. No caso dos rss o Calibre gera o formato “periodical”, no qual você navega pelos feeds clicando em tabs, como mostrado na figura abaixo:

Pensei, seria possível implementar algum script simples para simplesmente baixar os feeds e gerar um arquivo .mobi sem precisar de algum programa muito elaborado, como o Calibre pra isso? A reposta é sim, e é bem mais fácil do que pensei, se contarmos com o auxílio de algumas libs do python.

Basicamente, o que precisamos fazer é baixar cada notícia distribuída por rss ou atom, gerar um epub e utilizar o aplicativo kindlegen da Amazon para gerar o arquivo .mobi. Também não devemos esquecer de processar as imagens, ou seja, temos que fazer download das mesmas e referenciá-las localmente em cada artigo e colocá-las dentro do epub.

Primeiro, baixamos os feeds com o feedparser, com ele dada a url do feed podemos processar cada notícia, como mostrado no código abaixo exemplificando como  obtemos cada notícia (entries), imprimindo o título e o conteúdo.

import feedparser

feed = feedparser.parse('http://feeds.feedburner.com/JavaCodeGeeks')
for entry in feed.entries:
   print entry.title
   print entry.content[0]['value']

Em seguida, temos a parte mais trabalhosa: a geração do arquivo epub, que claro, segue um formato pré-determinado. Um arquivo epub é um zip (ver aqui) contendo alguns arquivos-padrão que descrevem o conteúdo e definem a navegação dentro do arquivo, seguindo a seguinte estrutura:

arquivo.epub/
META-INF/container.xml
content.opf
content.html
coverpage.xhtml
mimetype
toc.ncx

content.xml: é o arquivo que define o ponto de entrada da publicação, no nosso caso ele aponta para o arquivo “content.opf”
content.opf: define todos os arquivos que fazem parte da publicação, incluindo xhtml, css, imagens, opf, ncx, etc. Abaixo segue um exemplo de um content.opf para um epub com um único artigo contendo apenas uma imagem.

<?xml version='1.0' encoding='utf-8'?>
<package xmlns="http://www.idpf.org/2007/opf" unique-identifier="uuid_id" version="2.0">
  <metadata xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:opf="http://www.idpf.org/2007/opf" xmlns:dcterms="http://purl.org/dc/terms/"
   xmlns:dc="http://purl.org/dc/elements/1.1/">

    <dc:publisher>rss2kindle.py</dc:publisher>
    <dc:description> Generated by rss2kindle.py </dc:description>
    <dc:language>pt_BR</dc:language>
    <dc:creator opf:file-as="rss2kindle.py" opf:role="aut">rss2kindle.py</dc:creator>
    <dc:title>rss2kindle.py</dc:title>
    <meta name="cover" content="cover"/>
    <dc:date> 31/7/2014 </dc:date>
    <dc:contributor opf:role="bkp">rss2kindle.py</dc:contributor>
    <dc:identifier id="uuid_id" opf:scheme="uuid">72ebf8f1-9a52-4b8a-8013-cd5f54166b2a</dc:identifier>
    <meta name="rss2kindle:publication_type" content="periodical:unknown:Notícias"/>

     <x-metadata>
      <output content-type="application/x-mobipocket-subscription-magazine" encoding="utf-8"/>
     </x-metadata>

    </metadata>

    <item href="cover.jpg" id="cover" media-type="image/jpeg"/>

    <manifest>
       <item href="coverpage.xhtml" id="coverpage" media-type="application/xhtml+xml"/>
       <item href="toc.ncx" id="tocncx" media-type="application/x-dtbncx+xml"/>
       <item href="contents.html" id="contents" media-type="application/xhtml+xml"/>

       <item href="article_0.html" id="id0" media-type="application/xhtml+xml"/>
       <item href="images/Weekend_Nerd_image_0.jpeg" id="id20" media-type="image/jpeg"/>
     </manifest>

     <spine toc="tocncx">
       <itemref idref="coverpage"/>
       <itemref idref="contents"/>
       <itemref idref="id0"/>
     </spine>

     <guide>
        <reference href="contents.html" type="toc" title="Table of Contents"/>
     </guide>

</package>

Nas linhas 19 a 20 temos as tags que devemos adicionar no content.opf para fazer com que nosso epub seja visualizado com tabs e não como um ebook normal, como mostrado na figura anterior. Mais detalhes veja a thread sobre esse assunto na stackoverflow.

Dentro da seção manifest definimos os arquivos que farão parte do epub, incluindo imagens. No código acima definimos uma página de rosto (coverpage.html), o índice (toc.ncx) ,content.html e os artigos e figuras que iremos exibir, cada um id definido que, posteriormente será usado na seção spine, onde é definida uma ordem linear de exibição do documento. Mais detalhes sobre o content.opf veja nesse link.

toc.ncx: define a hierarquia e também a navegação entre os capítulos, seções e subseções de um epub. Abaixo o exemplo de conteúdo desse arquivo para apenas um artigo. Repare que dentro de navMap definimos a hierarquia do nosso epub dividido em seções, que no nosso caso correspondem aos feeds que queremos ler, cada um correspondendo a um navPoint, com os respectivos artigos aninhados, também por um navPoint.

<?xml version='1.0' encoding='utf-8'?>
<ncx xmlns:mbp="http://mobipocket.com/ns/mbp" xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1" xml:lang="eng">
  <head>
    <meta content="45112bf4-0a26-406d-8207-148c3350e36c" name="dtb:uid"/>
    <meta content="3" name="dtb:depth"/>
    <meta content="rss2kindle.py" name="dtb:generator"/>
    <meta content="0" name="dtb:totalPageCount"/>
    <meta content="0" name="dtb:maxPageNumber"/>
  </head>
  <docTitle>
    <text>RSS Feeds Generated by python</text>
  </docTitle>

  <navMap>
    <navPoint playOrder="0" class="periodical" id="periodical">
    <navLabel>
      <text>Table of Contents</text>
    </navLabel>
    <content src="contents.html"/>

    <navPoint class="section" id="num_1" playOrder="1">
      <navLabel>
        <text>Weekend Nerd</text>
      </navLabel>
     <content src="article_0.html"/>

       <navPoint class="article" id="num_2" playOrder="2">
         <navLabel>
             <text>Python é lento? Que Python?</text>
         </navLabel>
         <content src="article_0.html"/>
         <mbp:meta name="description"> Originally posted on a href="http://pythonhelp.wordpress.com/2013/11/19/python-e-lento-que-python"</mbp:meta>
         <mbp:meta name="author">Eduardo</mbp:meta>
       </navPoint>
      </navPoint>
   </navPoint>
  </navMap>
</ncx>

content.html: não é um arquivo obrigatório do epub, mas eu prefiro criar e referenciá-lo no primeiro navPoint, contendo o índice do ebook. Abaixo temos o conteúdo dele, onde o nome de cada feed aparece na tag h4 seguido de uma lista de artigos baixados em cada feed, nas tags ul e li. Repare que cada li aponta para o arquivo html do artigo. No kindle quando você visualiza o content.html, basta clicar no em um dos links abaixo para ir direito ao artigo que você quer ler.

<html>
  <head>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
    <title>Table of Contents</title>
  </head>
  <body>
    <h1>rss2kindle.py</h1>
    <h4>Weekend Nerd</h4>
      <ul>
          <li><a href='article_0.html'>Python é lento? Que Python?</a></li>
      </ul>
  </body>
</html>

coverpage.xhtml: arquivo onde você define uma capa ou folha de rosto do epub. No nosso caso ele contém apenas uma figura para ser exibida no kindle quando visualizarmos nossos ebooks no modo “cover view”, como mostrado no código e na figura abaixo:

 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <meta name="cover" content="true"/>
        <title>Cover</title>
        <style type="text/css" title="override_css">
            @page {padding: 0pt; margin:0pt}
            body { text-align: center; padding:0pt; margin: 0pt; }
        </style>
         <link rel="stylesheet" type="text/css" >
    </head>
    <body>

      <h1>rss2kindle.py</h1>
      <h2> 31/7/2014 </h2>

        <div>
            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1"
            width="100%" height="100%" viewBox="0 0 590 750" preserveAspectRatio="none">
                <image width="590" height="750" xlink:href="cover.jpg"/>
            </svg>
        </div>
    </body>
</html>

mimetype: arquivo contendo o tipo de publicação. No nosso caso ele sempre terá uma linha contendo: “application/epub+zip”

Agora que conhecemos como é um epub por dentro podemos fazer um programa que gere o conteúdo dos arquivos mostrados acima da seguinte maneira:

1) Cada feed corresponderá a um navPoint da classe section em toc.ncx e cada artigo do feed corresponderá a um navPoint da classe ‘article’ aninhado ao primeiro.

2) Cada artigo baixado e suas imagens terão um item correspondente em content.opf, na seções manifest e spine.

3) Em content.html, para cada feed criamos um heading h4 colocando o nome dele seguido de um lista ul contendo o link para cada artigo.

4) empacotamos todos os arquivos em zip e renomeamos para .epub

5) Com o kindlegen geramos o .mobi

No caso das imagens eu utilizei uma lib específica para manipular HTML’s, a Beautiful Soap. Tentei aglumas outras que já vem com o python, mas o resultado não era muito legal, até que pesquisando na internet achei um blog que apresenta o uso dela justamente na geração de um epub com figuras.

Uma coisa que achei fantástico em python foi a facilidade de geração dos arquivos toc.ncx e content.opf devido ao suporte que a linguagem oferece para manipular strings de múltiplas linhas sem ter que utilizar uma lib externa para isso. Basta substituir, na string, variáveis identificados com “%(nome_variavel)tipo da variável” passando um mapa contendo os valores, como se fosse uma template.

O código abaixo mostra como gerar o navPoint no toc.ncx para cada artigo do feed.

article_navpoint_tpl = """
      <navPoint class="article" id="num_%(order)s" playOrder="%(order)s">
          <navLabel>
            <text>%(article_title)s</text>
          </navLabel>
          <content src="%(article_link)s"/>
          <mbp:meta name="description"> %(description)s </mbp:meta>
          <mbp:meta name="author">%(author)s</mbp:meta>
        </navPoint>
"""

article_navpoint_tpl % {"article_title":entry.title, \
                        "article_link": "article_{0}.html".format(article_counter),\
                        "order": play_order,\
                        "description": description,\
                        "author":entry.author}

O código completo do script python para gerar o epub você pode encontrar aqui e, o link pra o meu pequeno projeto de gerador de periódicos para kindle, o rss2kindle.py, no github está aqui. Agora não preciso mais ficar instalando e configurando algum aplicativo ou me inscrever em sites que fazem a envio de artigos para o kindle através da internet, para poder ler os meus feeds favoritos.

Abaixo dois arquivos gerados pelo rss2kindle:

rss2kindle_2014820.epub

rss2kindle_2014820.mobi

Micro web frameworks em Python: experimentando o Bottle.py

Estamos geralmente acostumados a trabalhar com frameworks web complicados, principalmente os desenvolvedores java/JEE, cheios de funcionalidades e opções que muitas vezes, para fazer um aplicativo pequeno, como um blog ou uma lista de tarefas, provocam um desânimo só de pensar em ter que configurar maven, xml’s, properties e por aí vai.

Em outras linguagens como ruby ou python temos frameworks muito fáceis de aprender  como o Ruby on Rails, Django e Web2py (esse último tem conceitos bem interessantes que vou explorar em um post futuro). Mesmo assim, se você ainda quiser uma coisa mais simples por que acha que não precisa de tantas funcionalidades, como aquelas disponíveis no Rails ou o Django, ou ainda, você não quer instalar nada, ter que gerenciar pacotes de pendências e esse tipo de coisa, talvez seja interessante olhar para os micro-frameworks, que oferecem apenas o mínimo necessário para se implementar um aplicativo web.

Nesse post eu descrevo apenas minha experiência com o bottle.py, embora o mesmo valha para outros microframeworks semelhantes, como o flask, tido por alguns como o mais completo e com mais suporte da comunidade.

O framework bottle pode ser usado como um módulo python sem dependências adicionais. Inclusive, você pode baixá-lo do site e incluir no seu projeto facilmente por que ele é constituído de apenas um arquivo. Ele implementa o padrão WSGI e suporta roteamento, templates de views, upload de arquivos, cookies e inclusive websockets. Também conta com a possibilidade do uso de plugins de terceiros.

O famoso hello world é mostrado no código abaixo:

from bottle import route, run, template

@route('/hello/')
def index(name='World'):
  return template('Hello {{name}}!', name=name)

run(host='localhost', port=8080, debug=True)

e reparem na semelhança com o flask:

from flask import Flask
app = Flask(__name__)

@app.route('/';)
def hello():
 return 'Hello World!;

if __name__ == '__main__&quot':
 app.run()

De acordo com o código acima, os decorators do python são utilizados para realizar o mapeando das url’s. Os parâmetros das url’s correspondem aos parâmetros dos métodos decorados, cujo retorno pode apontar para uma template a ser renderizada, um redirecionamento ou um código HTTP. É possível também responder em formato JSON e XML, caso a intenção seja implementar uma API REST.

O bottle possui uma template engine embutida (embora suporte outras mais conhecidas como a jinja2) chamada Simple Template ou stpl muito fácil de aprender. Os parâmetros paras as views são passadas via dicionários como no exemplo abaixo, que retorna uma lista de posts:

@route('/posts')
def posts():
  posts = find_all()
  return template('index', dict(posts=posts))

Nas linhas abaixo, segui o mesmo exemplo de primeiro projeto quando somos apresentados ao rails, a implementação de um blog. O código completo está disponível no github nesse link.

Começamos pelo modelo de Post, bem simples, que terá um título, uma data e um conteúdo. Aproveitando que estava aprendendo um pouco de python e bottle, inclui mais um framework, de ORM, na brincadeira, para mapear o objeto Post para a camada de persistência. Resolvi utilizar o SQLAlchemy que parece ser o mais recomendado de acordo com o site stackoverflow. Abaixo temos o nosso modelo de Post:

from sqlalchemy.engine import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.schema import Column, Sequence
from sqlalchemy.types import Integer, String, DateTime

#definicao do banco de dados
DATABASE='sqlite:///blog.db';
engine = create_engine(DATABASE, echo=True)
BASE = declarative_base(engine)

class Post(BASE):
   '''modelo de post'''
   __tablename__ = 'posts'
   id = Column(Integer, Sequence('post_id_seq'), primary_key=True)
   title = Column(String(250))
   content = Column(String())
   date=Column(DateTime())

def __init__(self, title, content, date):
   self.title = title
   self.content = content
   self.date = date

def __repr__(self):
   return '%s, %s, %s', (self.id, self.title, self.date)

BASE.metadata.create_all(engine)

Em seguida, precisamos implementar um controlador para realizar as operações de criação, edição e exclusão dos posts. Abaixo segue o código:

from model.post import Post, DATABASE
from sqlalchemy.engine import create_engine
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.sql.expression import desc

def get_connection():
  """
  Connect to our SQLite database and return a Session object
  """
  engine = create_engine(DATABASE, echo=True)
  Session = sessionmaker(bind=engine)
  session = Session()
  return session

def save(post):
  if post.title != '' and post.title != None:
   session = get_connection()
   session.add(post)
   session.commit()
   session.close()
  else:
   raise Exception(u'Title cannot be empty')

def update_post(post):
  if post:
    session = get_connection()
    session.query(Post).filter(Post.id == post.id).update({'title':post.title, \
    'date':post.date, 'content':post.content})
    session.commit()
    session.close()

def delete_post(post):
  if post:
   session = get_connection()
   session.delete(post)
   session.commit()
   session.close()

def find_by_id(id):
  session = get_connection()
  post = session.query(Post).filter(Post.id==id).first()
  session.close()
  return post

def find_all():
  session = get_connection()
  posts = session.query(Post).order_by(desc(Post.date))
  session.close()
  return posts

Agora que temos nossa camada de persistência e um controlador, vamos a parte que interessa, a implementação da camada web. Praticamente, essa fase corresponde a mapear as url’s que desejamos expôr e fazer as respectivas chamadas para o nosso controlador persistir as mudanças e os posts criados.

No código abaixo temos algumas linhas destacadas que vale a pena explicar. As linhas 8 até 14 definem um método auxiliar para renderizar as views passando seus argumentos, incluindo uma mensagem de erro, pois o bottle não apresenta o flash do rails ou algo parecido (pelo menos não achei nada na documentação).

Também faltam mensagens automáticas de validação em forms tal como ocorre no Rails ou web2py. Mas é uma boa oportunidade para vc aprender a fazer o seu lendo os códigos-fontes de outros frameworks.

Nas linhas 16 a 18 o método send_static é utilizado para servir arquivos estáticos como figuras, css e javascripts, etc. Qualquer link apontando para ‘/assests/js/hello.js’, por exemplo, será mapeado por este método para, o arquivo localizado em views/js/hello.js. Esses paths dependem de onde o programa principal está sendo executado. Maiores detalhes você encontra na documentação do bottle.

Finalmente, nas linhas 79 a 81 definimos um método que será executado sempre que ocorrer o erro 404 do HTTP, de forma a exibir a uma página padrão de erro.

# -*- coding: utf-8 -*-
from bottle import get, post, request, route, run, template, view, redirect, \
static_file, error
from controller.postcontroller import *
from model.post import Post
import datetime

def render_template(args, kwargs=None, error=None, msg_success=None):
 if kwargs == None:
  kwargs = dict()

 kwargs['error']=error
 kwargs['msg_success']=msg_success
 return template(args, kwargs)

@route('/assets/')
def send_static(filename):
 return static_file(filename, root='views')

@route('/posts')
def posts():
  '''Listing of posts'''
  posts = find_all()
  return render_template('index', dict(posts=posts))

@route('/post/')
def get_post(id):
  '''Get post given the id'''
  return 'Not Implemented Yet';

@get('/posts/new')
def new():
  '''create a empty post to fill the new form'''
  today = datetime.date.today()
  return render_template('new', dict(post=Post(None, None, today)))

@post('/post/create')
def create():
  '''Get the attributes from request and create a new post'''
  post = build(request)
  try:
   save(post)
  except Exception as e:
   return render_template('new', dict(post=post), \
   error='Title cannot be empty')
 redirect('/posts')

@get('/posts/edit')
def edit(id):
 if id:
  post = find_by_id(id)
  if post:
    return render_template('edit', dict(post=post))

 posts=find_all()
 return render_template('index', dict(posts=posts), error='Post not found')

@route('/post/update/:id', method='POST')
def update(id):
  if id:
    post = find_by_id(id)

  if post:
    post_from_request = build(request)
    post.title = post_from_request.title
    post.date = post_from_request.date
    post.content = post_from_request.content
    update_post(post)

 posts = find_all()
 return render_template('index', dict(posts=posts), \
                        msg_success='Post edited with success')

@route('/posts/delete/:id', method='POST')
def delete(id):
 post = find_by_id(id)
 delete_post(post)

@error(404)
def error404(error):
  return 'Nothing here, sorry'

def build(request):
 '''
 Extract from the request the parameters to create the new post
 '''
 title = request.forms.get('title')
 content = request.forms.get('content')
 day,month,year = request.forms.get('date').split('/')
 return Post(title, content,  datetime.date(int(year),int(month),int(day)))

if __name__ == '__main__':
 run(host='localhost', port=9090)

Agora, faltam as views, que como dito anteriormente são implementadas com uma engine de template própria do framework. O código abaixo dá uma idéia dessas views. Não listaremos todas elas por questão de espaço. Mas o código completo você pode pegar no github e ver como o código está organizado.

%rebase layout title="New Post"

%if error:
    <div class="alert alert-error">
        {{error}}
    </div>
%end

<form action="/post/create" method="post">
   <fieldset>
     <input id="date" type="text" name="date" 
            value="{{post.date.strftime('%d/%m/%Y')}}" />
     <label for="title">Title</label>
     <input id="title" type="text" name="title" />
     <textarea id="content" cols="400" name="content" rows="10">
        {{post.content or ''}}
     </textarea>
     <button class="btn" type="submit">Submit</button>
   </fieldset>
</form>
<script type="text/javascript">
// <![CDATA[
$(function(){   
  $( "#date" ).datepicker({dateFormat:'dd/mm/yy'});   
});
// ]]>
</script>

No código acima, na linha 1 indica um layout padrão a ser renderizado junto com a view evitando repetição de código entre várias páginas. E, nas linhas 3 a 7 temos o exemplo de como exibir uma mensagem de erro quando esta ocorre. Nota-se que o  código da view é bem simples, usa-se código python sem maiores traumas, nada muito diferente de outras templates como a ERB do Rails.

No código do controlador as linhas 92-93 são responsáveis por inicializar o servidor http. Basta digitar a seguinte linha no terminal e acessar http://localhost:9090/posts:

 python blog.py

Apesar do Bottle não possuir features muito avançadas para desenvolvimento web ele me pareceu bem interessante para implementar coisas pequenas e rápidas, inclusive uma API REST. A implementação desse exemplo foi bem rápida e não faz muito tempo que aprendi o básico da linguagem python.

Na minha opinião é um ótimo framework para implementar aplicativos com poucas funcionalidades e principalmente se você deseja executá-lo em várias máquinas sem precisar instalar vários pacotes, ou se você não tem a senha de administrador da máquina, por exemplo. Basta ter python instalado, o que acontece na maiorias das distribuições linux e no OSX. Por outro lado, se temos que implementar um aplicativo mais complexo, com vários objetos na camada de modelo, com diversas validações e relacionamentos entre os mesmos, talvez não seja a melhor opção por nos obrigar a implementar vários códigos adjacentes, como por exemplo a validação de objetos antes de persistir e exibição de mensagens de erros ou sucesso, o que no Rails, é feito de maneira bem intuitiva e com poucas linhas de código.

Como o código é aberto você pode baixá-lo da internet e ler o código-fonte caso queria entender como funciona um framework web, sendo essa, a sua principal vantagem. É uma ótima fonte de estudo para quem deseja entender como funciona a internet e um pouco do protocolo HTTP. E no caso de se sentir confortável o bastante, desenvolver seu próprio framework web adicionando opções mais avançadas de acordo com a necessidade.

Referências:
Bottle.py: http://bottlepy.org/docs/dev/index.html

PyBlog, código-fonte de exemplo:
https://github.com/eduardocl/pyblog

Outros frameworks minimalistas:
werkzeug: http://werkzeug.pocoo.org/

Flask: http://flask.pocoo.org