avelino.us's Weblog

VIM a IDE para programadores Python

avelino@chierry.com (avelino) — Thu, 22 Dec 2011 07:58:00 -0600

Depois muito tempo sem escrever nada no meu blog, escolhi esse tema para chamar a atenção do pessoal que esta começando desenvolver em Python que sempre pergunta qual é a melhor IDE para desenvolver em Python ou qual quer programador que usa uma super IDE pesado porque tem o recurso X, Y e Z.

Com o VIM podemos ter todos os recurso avançado que temos em qual quer IDE, basta algumas configurações para que esses recursos ser ativado, para facilitar a vida de todos compartilhei o meu .vimrc e nesse post vou explicar como usar o mesmo.

"Em 2 de novembro de 1991, Bram Moolenaar publicava a primeira versão do edito vim. O vim nasceu como um clone para Amiga do editor vi criado por Bill Joy em 1976, adicionando algumas funcionalidades extras, daí seu nome (VI iMproved ou VI Melhorado). Este editor se adaptou rapidamente a outras plataformas. "

Assumindo que o vi já esta instalado no meu micro, vamos instalar as configurações que eu fiz, basta rodar os seguintes comando no seu bash (Linux ou Mac):

curl https://raw.github.com/avelino/.vimrc/master/bootstrap.sh -o - | sh

Após isso ele vai baixar o repositório na sua pasta HOME. Recomendo o uso o VIM em GUI pois podemos chegar 256 cores, ou seja, colocar temas mais agradável e assim deixando o uso do vim mais confortável para o desenvolvimento, para Linux é o gvim e para mac o macvim (Para mac o Björn Winckler fez um ótimo trabalho, na minha humilde opinião é a melhor versão do VIM via GUI).

Chega de blablabla né, vamos logo para o que realmente interessa, como o VIM ficou e como utilizar ele?

Usando o vim para navegar nas pasta de um projeto:

Buscando arquivo por nome dentro do projeto:

Listar todas as class e def do arquivo esta esta aberto (Python)

Lista de comandos para usar no 'vim', lembrando que esses comando foi customizado:

:cd /path Abrir pasta
tn Abrir nova aba
te Abrir nova aba e carregar arquivo
t] Proxima aba
t[ Voltar aba
Ctrl+c Adicionar todos os arquivos no cache para poder fazer busca de arquivo (recomendo fazer isso ao abrir o projeto)
Ctrl+f Busca arquivo e abre na mesma aba
Ctrl+s Busca arquivo e abre em uma nova aba
\b Abre arquivo que esta no buffer do vim (Arquivo abertos)
\d, \n ou F3 Abre navegador de arquivo
\f Lista todas as class e def (Python)
\j Vai para declaração de um metodo
\r Renomear todos os metodos
[e Move linha para cima
e] Move linha para baixo
\v ouCtrl+w + v` Divide a tela em vertical
\h ou Ctrl+w + s Divide a tela em horizontal
\w ou Ctrl+w + q Fecha a aba atual
Ctrl+k Abre console Python
Ctrl+j Roda o script Python aberto
\sh Abre bash (shell)
\p Manda o arquivo em aberto para o dpaste.com
\ga Git add .
\gc Git commit
\gsh Git push
\gs Git status
\gd Git diff
\gr Git remove
\S Remove todos os espaços do final
\c Lista controle de versao do buffer

Google Nexus S, atualização oficial para Android 4.0 (Ice Cream Sandwich)

avelino@chierry.com (avelino) — Sat, 17 Dec 2011 11:41:09 -0600

Dia 16/12/2011 o Google lançou oficialmente a atualização do aparelho Nexus S para Ice Cream Sandwich (Android 4.0), a noticia saiu no Twitter oficial do Google Nexus.

Para você atualizar o seu Nexus S faça o seguinte procedimento:

1 - Faça download da imagem do Android 4.0 para o Nexus S no seguinte link: http://android.clients.google.com/packages/ota/google_crespo/VQ8PQk_V.zip ou http://dl.dropbox.com/u/763381/VQ8PQk_V.zip
2 - Coloque o VQ8PQk_V.zip SD do seu Nexus S e você deve renomear o arquivo para update.zip
3 - Desligue o seu aparelho
4 - Aperte o botão do volume para cima + o botão power, seu celular vai iniciar no modulo fastboot
5 - Selecione a opção recovery
6 - Vai começa carregar e aparecera um triângulo com um !, nessa tela você deve aperta o botão power + volume para cima (Deve ser na sequência relatado no post)
7 - Vai aparecer um menu onde você deve selecionar a seguinte opção Apply update from /sdcard
8 - Após instalar você deve selecionar reboot system now
9 - Pronto, Android 4.0.3 instalado no seu Nexus S

Quando o seu celular for ligar a primeira vez com Android 4.0 ele vai ficar um pouco lento pois vai refazer o dalvik cache.

Lembrando que você tem que ter a versão do Android oficial do Google instalado no seu Nexus S, caso não esteja não vai conseguir fazer os procedimentos, pois estamos atualizando para a versão oficial do Google.

O Google vai liberar aos poucos a atualização automatica para os Nexus S pois se não vai acabar com o link das operadoras, no Brasil principalmente que nosso 3G é um 2G.

Nova versão da API do Dropbox

avelino@chierry.com (avelino) — Thu, 13 Oct 2011 22:23:54 -0500

Dia 14.09.2011 o Dropbox lançou a nova versão 1.0 da API, nesse lançamento trouxe muitas novidades e melhorias:

Suporte para aplicações web
Suporte para criação de pasta (Na versão 0.1 da API não tinha)
Novo site para desenvolvedores, com documentação simples e completa https://www.dropbox.com/developers_beta
Melhor compartilhamento de arquivo, streaming, busca por arquivo e suporte para revisão de arquivo
Implementação no controle de nomes de arquivos, para não sobrescrever arquivos já salvo
SDK atualizado para iOS, Android, Python, Ruby e Java que implementa todas modificações e documentação

Link do repositorio (Python Pypi) da nova biblioteca http://pypi.python.org/pypi/dropbox/1.1

O dropbox implementou um oauth onde podemos desenvolver software e fazer o usuário usar a conta de dropbox dele para armazenamento de arquivos:

Vou falar um pouco sobre 3 metodos que esta dentro da biblioteca "dropbox" client, rest e session:

Com o metodo session é por onde tudo começa, onde você linka o seu software com uma conta Dropbox, exemplo:

# Include the Dropbox SDK libraries
from dropbox import session

# Get your app key and secret from the Dropbox developer website
APP_KEY = 'INSERT_APP_KEY_HERE'
APP_SECRET = 'INSERT_SECRET_HERE'

# ACCESS_TYPE should be 'dropbox' or 'app_folder' as configured for your app
ACCESS_TYPE = 'INSERT_ACCESS_TYPE_HERE'
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)

Caso esteja usando a conta do Dropbox do usuário podemos pegar informações da conta dele:

client = client.DropboxClient(sess)
print "linked account:", client.account_info()

Agora usando o metodo "client" podemos fazer get e put de arquivos:

from dropbox import client
f = open('working-draft.txt')
response = client.put_file('/magnum-opus.txt', f)
print "uploaded:", response

Após criar o arquivos podemos ler ele:

print client.get_file('/magnum-opus.txt').read()

Reescrever o arquivo com uma nova revisão para criar um novo arquivo:

out = open('magnum-opus.txt', 'w')
out.write(client.get_file('/magnum-opus.txt',rev='362e2029684fe').read())

Para trabalhar com REST temos um ótima documentação https://www.dropbox.com/developers_beta/reference/api

Problema com hashlib + md5 (Python 2.7)

avelino@chierry.com (avelino) — Tue, 04 Oct 2011 15:04:46 -0500

Estava com o seguinte problema "Error: No module named _md5", primeiramente pensei que foce problema de de compilação do Python, mas olhando o problema proximo achei alguns artigo falando desse problema e um deles estava no bug.python.org

A solução que cheguei foi, criar uma lib chamada "_md5", criei um arquivo chamado "_md5py":

class _md5:
    def __init__():
        import md5
        return md5

Lendo as documentação vi que a lib "hashlib._md5" foi deprecada pois a md5 ficou no lugar. Espero que ajude outras pessoas que esta com esse problema.

Porque fazer teste unitario em javascript?

avelino@chierry.com (avelino) — Thu, 21 Jul 2011 23:22:27 -0500

É complicado confiar em um software que não tem teste unitario. Hoje estava escrevendo alguns códigos em JavaScript e resolvi escrever esse post pois muitos desenvolvedores JavaScript não costumam testar seus códigos.

QUnit é um Framework open source de teste unitário para JavaScript. Ele foi desenvolvido para fazer teste unitários no desenvolvimento do próprio Jquery, mas é capaz de testar qualquer código Javascript (Até mesmo testar código Javascript do lado do servidor NodeJS).

Segue abaixo o exemplo de uma implementação simples:

<html>
<head>
  <script src="http://code.jquery.com/jquery-latest.js"></script>
  <link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
  <script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>
  <script>
    function calc(val1, val2, oper){
      val1 = typeof val1 == 'undefined' ? 0 : val1
      val2 = typeof val2 == 'undefined' ? 0 : val2
      oper = typeof oper == 'undefined' ? "+" : oper

      if(oper == "+")
        cal = val1 + val2
      else if(oper == "-")
        cal = val1 - val2
      else
        cal = false

      return cal
    }
  </script>

  <script>
    $(document).ready(function(){

      module("Test render html")
      test("test valor in #test1", function(){
        equals("ok ok ok", $("#test1").html())
        notEqual("ok ok ok ", $("#test1").html())
      })

      module("Test function calc()")
      test("test basic return 10", function(){
        equals(10, calc(10))
        notEqual(10, calc(11))
      })

      test("test basic sum 2 parameter", function(){
        equals(20, calc(10, 10))
        notEqual(21, calc(10, 10))
        deepEqual(20, calc(10, 10))
        notStrictEqual("20", calc(10, 10))
      })

      test("set operator +", function(){
        equals(20, calc(10, 10, "+"))
        equals(false, calc(10, 10, "..."))
      })

      test("set operator -", function(){
        equals(1, calc(10, 9, "-"))
      })

    })
  </script>

</head>
<body>
  <h1 id="qunit-header">QUnit example</h1>
  <h2 id="qunit-banner"></h2>
  <div id="qunit-testrunner-toolbar"></div>
  <h2 id="qunit-userAgent"></h2>
  <ol id="qunit-tests"></ol>
  <div id="qunit-fixture">test markup, will be hidden</div>

  <div id="test1">ok ok ok</div>
</body>
</html>

No código acima estou fazendo dois tipos de testes: um módulo de item renderizado na página, e outro módulo de teste de uma função de cálculo.

Segue abaixo o print de como ficou o test:

Template Django com Haml

avelino@chierry.com (avelino) — Sat, 28 May 2011 09:24:57 -0500

Haml (HTML Abstraction Markup Language) é uma linguagem simples, que é usado para descrever XHTML de qualquer documento web sem precisar ficar abrindo e fechando tags HTML. Ele foi projetado para resolver muitos dos problemas de templates, bem como fazer marcação tão elegante como ela pode ser.

Em Python temos a biblioteca HamlPy ela pega os files HAML e gera o HTML para usarmos em nossos sistemas.

Vamos logo para a pratica, chega de lero lero.

%html{'xmlns':"http://www.w3.org/1999/xhtml", 'lang':"en", "xml:lang":"en"}
  %head

    %title Testando Haml

    %style{'type': 'text/css'}
      body{font-family: verdana;}

    %script{'type':'text/javascript', 'src':'https://www.google.com/jsapi?key=ABQIAAAAUgaJsDgRTDbR5vvhnJ3iYBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxS2j2XMXVpjyqg8A7TkHl2W04abvA'}
    %script{'type': 'text/javascript'}
      google.load("jquery", "1.6.1");

  %body
    #header
      %h1#lero
        .test Haml
        %ul.navigation
          - for run in varloop
            %li= run
    #content
      Testando para ver se funciona o HamlPy

Esse é um layout feito com haml, é muito simples pois não precisamos ficar fechando as tags, assim os erros de html é 100% resolvido, como converte o haml para html:

/Users/avelino/.virtualenvs/haml/bin/hamlpy template/index.haml template/index.html

O binario hamlpy recebe dois parâmetros o primeiro é o input file haml o segunda é o output a saída html, depois de rodarmos o hamlpy temos uma saida da seguinte forma:

<html lang='en' xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>
  <head>
    <title>Testando Haml</title>
    <style type='text/css'>
      body{font-family: verdana;}
    </style>
    <script src='https://www.google.com/jsapi?key=ABQIAAAAUgaJsDgRTDbR5vvhnJ3iYBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxS2j2XMXVpjyqg8A7TkHl2W04abvA' type='text/javascript'></script>
    <script type='text/javascript'>
      google.load("jquery", "1.6.1");
    </script>
  </head>
  <body>
    <div id='header'>
      <h1 id='lero'>
        <div class='test'>Haml</div>
        <ul class='navigation'>
          {% for run in varloop %}
            <li>{{ run }}</li>
          {% endfor %}
        </ul>
      </h1>
    </div>
    <div id='content'>
      Testando para ver se funciona o HamlPy
    </div>
  </body>
</html>

Minha views do Django declaro sempre com o arquivo .html que foi gerado com o hamlpy. Veja como ficou o meu views:

# -*- coding: utf-8 -*-
"""
    views

    :copyright: (c) 2011 by the Avelino Labs, see Thiago Avelino <thiago@avelino.us> for more details.
    :license: BSD, see LICENSE for more details.
"""

from django.shortcuts import render_to_response
from django.template import RequestContext

def index(request):
    return render_to_response(
            'index.html',
            context_instance=RequestContext(request))

Entendendo na pratica como funciona a linguagem Go

avelino@chierry.com (avelino) — Wed, 25 May 2011 08:01:40 -0500

A linguagem Go é um projeto open source para tornar os programadores mais produtivos.

Go foi desenvolvido para utilização maxima do CPU, tornando um processo simples para criar aplicação Multithreaded, o processo de utilização de maquinas na rede para processar determinado programa também é bem simples, assim tornando um software mais flexível e modular.

Vamos montar um servidor HTTPD em Go.

package main

import (
    "http";
    "io";
    "fmt";
)

func HelloServer(c *http.Conn, req *http.Request) {
    io.WriteString(c, "hello, world!\n");
}

func main() {
    fmt.Printf("http://localhost:8080/hello\n");
    http.Handle("/hello", http.HandlerFunc(HelloServer));
    err := http.ListenAndServe(":8080", nil);
    if err != nil {
        panic("ListenAndServe: ", err.String())
    }
}

O HelloServer() é o que vai fazer a parte de renderização, o man() ele sobre o servidor HTTP na porta 8080, e caso o usuário tente processar um URL que não esteja no fmt ele vai cair no err onde vai processar o erro e apresentar o panic. Simples assim já temos um servidor HTTP para toda HTTP.

[TOPICOFF] Site fora do ar, DataCenter tirando meu sono

avelino@chierry.com (avelino) — Fri, 29 Apr 2011 05:47:22 -0500

Peço 1001 desculpas por o Avelino.US ter ficado fora do ar durante os últimos 4 dias.

Depois de 8 mês o DataCenter onde estava meu site ele colocou algumas regrar para serviço contratado daquela data para frente e depois de 2 mês o DataCenter lançou a regra para os que já tinha servidor alugado, ou seja, todos os IP do servidor caiu.

Migramos de DataCenter e não vai mais ocorrer esse tipo de problema.

Upload da arquivo no Google App Engine (BlobProperty)

avelino@chierry.com (avelino) — Sat, 23 Apr 2011 13:50:11 -0500

Essa semana que passou tive uma necessidade para um sistema de trabalhar com UPLOAD de arquivos, ate ai é simples, só que o sistema estava em Google App Engine, depois de apanhar um pouco resolvi fazer um post aqui no Blog para deixar documentado como não é complicado trabalhar com BlobProperty no BigTable.

Primeiro vamos criar um Modal onde vai ter dois campo o arquivo e o mimetype dele:

class DatastoreFile(db.Model):
    data = db.BlobProperty(required=True)
    mimetype = db.StringProperty(required=True)

Agora vamos criar a views onde ele vai processar o formulario e o POST do formulario:

class MainHandler(webapp.RequestHandler):
    def get(self):
        self.response.out.write(template.render("upload.html", {}))

    def post(self):
        file = self.request.POST['file']

        entity = DatastoreFile(data=file.value, mimetype=file.type)
        entity.put()

        file_url = "http://%s/%d/%s" % (self.request.host, entity.key().id(), file.name)
        self.response.out.write("Your uploaded file is now available at %s" % (file_url,))

Podemos notar que na definição get() temos apenas a renderização do "upload.html", o conteudo dele é bem simples, temos um input do tipo file e outro submit:

<html>
<head>
  <title>File Upload</title>
</head>
<body>
  <form method="post" action="/" enctype="multipart/form-data">
    <input type="file" name="file" />
    <input type="submit" value="Upload" />
  </form>
</body>
</html>

Falando da definição post() que esta na classe MainHandler ela que faz o trabalho de fazer o UPLOAD do arquivo para dentro do BlobProperty, é um processo bem simples, a variável "file" recebe o POST do input file, depois disso chamamos o modal que tem o nome de DatastoreFile passando dois parâmetros que é os dois campos criados, o data e mimetype, depois disso é só fazer o put() que seja salvo no banco de dados. Dentro do post() eu gero o link para download do arquivo na variável file_url, onde passo o HOST (url do sistema), id() (do arquivo que foi feito upload) e file name (Nome do campo que recebeu o arquivo).

Agora temos que fazer a classe para download do arquivo onde vamos mudar o Content-Type do response para o mime-type do arquivo que foi feito o upload, exemplo: fiz o upload de um arquivo no formato JPG o mime type dele é "image/jpeg", então tenho que fazer o responser renderizar em formatado "image/jpeg".

Na URL que montamos para download passamos a seguinte informação id e file name onde temos que criar uma definição get() que receba essas informações:

class DownloadHandler(webapp.RequestHandler):
    def get(self, id, filename):
        entity = DatastoreFile.get_by_id(int(id))
        self.response.headers['Content-Type'] = entity.mimetype
        self.response.out.write(entity.data)

Recebendo as duas variáveis podemos fazer um consulta no BigTable de forma simples onde busco o id, pego o retorno do banco de dados e coloco que o response.headers['Content-Type'] é o mime-type que esta salvo no banco e depois é só escrever o arquivo na tela.

Agora vamos criar as rotas da URL:

def main():
    application = webapp.WSGIApplication([
        ('/', MainHandler),
        ('/(\d+)/(.*)', DownloadHandler)
        ],debug=True)
    util.run_wsgi_app(application)

if __name__ == '__main__':
    main()

Quem ainda estiver com duvida pode dar uma olhar no repositorio: https://bitbucket.org/avelino/post_py_upload_de_arquivo_no_gae/src

Criando sistema com Multithreaded em Python

avelino@chierry.com (avelino) — Fri, 01 Apr 2011 02:58:49 -0500

Multithreaded é quando temos mais de um programa executando ao mesmo tempo, totalmente diferente de executar duas vez o mesmo programa, com "threads" o sistema vai ser executado apenas uma vez e via thread vai processar mais de uma função ao mesmo tempo, isso é necessario para concorrência em sistema.

Algumas vantagens de trabalha com threads:

Múltiplos processo ao mesmo tempo e pode, portanto, compartilhar informações e comunicar uns com os outros mais facilmente do que se fossem processos separados;
Menos consumo de memória, pois o mesmo vai consumir mais CPU.

Uma thread tem um começo, meio e fim, assim podemos colocar um ponteiro de instrução para acompanhar onde esta sendo processado cada thread dentro de seu contexto.

Ela pode ser antecipada (interrompido);
Pode ser temporariamente suspensos (também conhecido como sleep), enquanto outros segmentos estão em execução - isso é chamado de rendimento.

Iniciando uma nova Thread:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import thread
import time

# Definição da função de thread
def print_time( name, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print "%s: %s" % ( name, time.ctime(time.time()) )

# Criar dois tópicos
try:
    thread.start_new_thread( print_time, ("Thread-1", 2, ) )
    thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
    print "Erro: não conseguiu iniciar a thread"

while 1:
    pass

Executando:

avelino:multithreading/ [11:01:01] $ python example.py
Thread-1: Thu Mar 31 11:03:20 2011
Thread-2: Thu Mar 31 11:03:22 2011
Thread-1: Thu Mar 31 11:03:22 2011
Thread-1: Thu Mar 31 11:03:24 2011
Thread-2: Thu Mar 31 11:03:26 2011
Thread-1: Thu Mar 31 11:03:26 2011
Thread-1: Thu Mar 31 11:03:28 2011
Thread-2: Thu Mar 31 11:03:30 2011
Thread-2: Thu Mar 31 11:03:34 2011
Thread-2: Thu Mar 31 11:03:38 2011

Se repararmos temos alguns processo concorrendo ao mesmo tempos, dessa forma já estamos trabalhando com Thread.

Modulos da biblioteca thread

threading.activeCount(): Retorna o número de objetos de thread que estão ativos.
threading.currentThread(): Retorna o número de objetos de thread no controle do chamador de thread.
threading.enumerate(): Retorna uma lista de todos os objetos de thread que estão atualmente activas.
run(): Método é o ponto de partida para uma thread.
start(): Método inicia uma thread, chamando o método de execução.
join([time]): Espera para terminar.
isAlive(): Método verifica se uma thread ainda está em execução.
getName(): Método retorno o nome de uma thread.
setName(): Método declaro o nome de um thread.

Trabalhando com Python e MongoDB

avelino@chierry.com (avelino) — Mon, 28 Mar 2011 13:12:15 -0500

Hoje MongoDB está começando ficar bem comentado na internet (famosos Database NoSQL). Tenho bastante aplicações em produção trabalhando com MongoDB e outros database NoSQL ambas escrita em Python, vou escrever um pouco como usar o MongoDB na linguagem Python.

Como em qualquer outra linguagem, não tem muito segredo. No Python temos a LIB chamada PyMongo, que simplifica muito o trabalho do programador.

Contando que o PyMongo já estejá instalado, seguimos em frente.

Como fazer um conexão:

>>> from pymongo import Connection
>>> connection = Connection()

>>> connection = Connection('localhost', 27017)

Usar/Criar um Database: >>> db = connection.forum_database

>>> db = connection['forum-database']

O MongoDB usa um formato jSON para sua syntax, veja abaixo:

>>> forum = {"author": "Thiago Avelino",
...         "text": "Python e MongoDB",
...         "tags": ["mongodb", "python", "pymongo"]}

Inserindo em um Documento, usando o método insert():

>>> imaster = db.imaster
>>> imaster.insert(forum)
ObjectId('4c7400f42d73303fd2000000')

Após rodar o insert() ele criou um documento fisico no servidor, podemos ver este registro da seguinte forma:

>>> db.collection_names()
[u'imaster', u'system.indexes']

Selecionando apenas um documento com find_one()

>>> imaster.find_one()
{u'text': u'Python e MongoDB', u'_id': ObjectId('4c7400f42d73303fd2000000'), u'author': u'Thiago Avelino', u'tags': [u'mongodb', u'python', u'pymongo']}

Filtrando, usando condições para selecionar:

>>> imaster.find_one({"author": "Thiago Avelino"})
{u'text': u'Python e MongoDB', u'_id': ObjectId('4c7400f42d73303fd2000000'), u'author': u'Thiago Avelino', u'tags': [u'mongodb', u'python', u'pymongo']}

Contando:

>>> imaster.count()
1

Temos também alguns ORM Python que trabalha com o MongoDB, um exemplo é o MongoEngine que trabalha exatamente igual o ORM do Django. Veja um exemplo usando MongoEngine:

class BlogPost(Document):
    title = StringField(required=True, max_length=200)
    posted = DateTimeField(default=datetime.datetime.now)
    tags = ListField(StringField(max_length=50))

class TextPost(BlogPost):
    content = StringField(required=True)

class LinkPost(BlogPost):
    url = StringField(required=True)

# Create a text-based post
>>> post1 = TextPost(title='Using MongoEngine', content='See the tutorial')
>>> post1.tags = ['mongodb', 'mongoengine']
>>> post1.save()

# Create a link-based post
>>> post2 = LinkPost(title='MongoEngine Docs', url='hmarr.com/mongoengine')
>>> post2.tags = ['mongoengine', 'documentation']
>>> post2.save()

# Iterate over all posts using the BlogPost superclass
>>> for post in BlogPost.objects:
...     print '===', post.title, '==='
...     if isinstance(post, TextPost):
...         print post.content
...     elif isinstance(post, LinkPost):
...         print 'Link:', post.url
...     print
...
=== Using MongoEngine ===
See the tutorial

=== MongoEngine Docs ===
Link: hmarr.com/mongoengine

>>> len(BlogPost.objects)
2
>>> len(HtmlPost.objects)
1
>>> len(LinkPost.objects)
1

# Find tagged posts
>>> len(BlogPost.objects(tags='mongoengine'))
2
>>> len(BlogPost.objects(tags='mongodb'))
1

Certificado EV SSL

avelino@chierry.com (avelino) — Mon, 28 Mar 2011 05:55:57 -0500

Certificados Digitais EV SSL, ou em português SSL de Validação Avançada, são certificados qualificados que se apresentam aos usuários da Internet de forma distinta dos demais certificados, garantindo assim aos usuários que o site acessado possui um certificado SSL emitido segundo um processo altamente seguro e verificado através de uma auditoria.

História

O Comércio via Internet está enfrentando uma crise de segurança. A confiança na segurança de sites está diminuindo, e o número de consumidores que estão deixando de fazer transações on-line está aumentando. Segundo o instituto Forrester Research, ao final de 2005, 24% dos usuários de Internet não compraria via web para os feriados de final de ano pois não se sentiam seguros e 61% reportou que haviam reduzido as compras online por algum motivo.

Agora em 2007 empresas com operações online poderão mostrar definitivamente sua identidade para os seus clientes – e os clientes poderão confirmar esta identidade antes de confiar no site. Essa oportunidade se deve ao resultado da grande evolução no backbone de segurança WEB nos últimos 10 anos. É a introdução de um novo tipo de certificado SSL, o primeiro desde a origem desta tecnologia há mais de uma década atrás.

Estes novos certificados são chamados Certificados Extended Validation SSL e eles representam mais de um ano de esforços feitos pelo CA/Browser Fórum, um consórcio de empresas líderes em manutenção de Browser e Autoridades Certificadoras de SSL. Os Certificados EV SSL irão facilitar o comércio online em todas as suas formas, aumentando a confiança dos usuários, legitimando sites e reduzindo significativamente a eficácia dos ataques de fraude e roubo de senha.

EV SSL no Brasil

No Brasil o certificado está sendo comercializado pela Certisign, Unicert, Comodo e Secsign. Até o final do ano estima-se que do total de vendas de certificados para servidores, 20% sejam no modelo EV SSL. Segundo a projeção da Certisign, isso significa a venda de quase 4.500 certificados.

Espera-se que no prazo de dois anos todas as empresas que se prestam a realizar transações on-line (como sites de e-commerce, bancos, etc...) adotem este produto, pois ele garante identificação visual, maior segurança e conforto para o consumidor.

Coding Dojo o melhor lugar para pratica Programação

avelino@chierry.com (avelino) — Mon, 21 Feb 2011 10:16:13 -0600

Nós da Comunidade Python São Paulo estamos no 10' Dojo.

Parabéns a todos os organizadores e participantes.

Agradeço a todas as empresa que abriu a porta para nós da Comunidade Python São Paulo poder realizar o Coding Dojo.

Dojo é uma reunião onde um grupo de programadores se reúnem para trabalhar em um desafio de programação. Eles estão lá para se divertir e se envolver em prática a fim de melhorar suas habilidades.

Veja a baixo videos gravado no 10' Dojo da Comunidade Python São Paulo onde foi realizado na empresa Gonow Tecnologia:

Veja o post completo que foi postado no Blog da Gonow.

Meu ambiente de trabalho em 7 itens

avelino@chierry.com (avelino) — Sun, 20 Feb 2011 20:09:35 -0600

O Licio me convidou para entrar no ritmo dos "7 itens" então vamos lá...

GIT + Mercurial Geralmente procuro usar Mercurial no Bitbucket mas costumo usar bastante Git no Github. Uso o Github porque vejo ele muito mais do que um espaço para criar repositórios, e sim uma rede social de Desenvolvedor.
VIM Depois de muito testar o Emacs, TextMate e VIM, resolvi afirma que para mim o melhor é o VIM, consigo fazer tudo que preciso e não tenho tantos problemas com " como no TextMate. Falando um pouco sobre o Emacs, realmente é um ótimo editor, só que cansa brincar de street fighter quando vou programar (Para os que conhece Emacs vai entender). Depois de conhecer o QMX (Evangelista VIM) comecei ver o VIM como um ótimo editor.
OS X Depois de passar muito tempo com ambiente Linux, vi que não bastava a simplicidade de um gerenciamento de pacote como yum ou apt-get e sim um sistema onde conseguisse uma melhor integração com a camada de hardware. Por isso hoje uso Macbook, com o sistema operacional OS X.

E a bateria dura muito mais tempo do que qual quer outro Notebook que eu tive.
iterm2 + homebrew Utilizo o iterm2 como terminal do meu Mac e tem me agradado muito a parte de troca de abas, como gerenciador de pacote utilizo o homebrew (que me foi apresentado pelo Fabio Akita, automaticamente já sabemos que é escrito em Ruby :/ )
pip + virtualenv + virtualenvwrapper Como sou desenvolvedor Python não temos trabalhar com ultiplos projetos sem um Virtualenv para isolar meus ambientes para cada projeto, o Virtualenvwrapper uso para simplificar a criação de cada ambiente e o pip uso para instalar bibliotecas Python.
Dropbox Realmente o Dropbox me salvou muitas vezes, com o uso dele não preciso ficar levando pen drive para cliente ou qual quer local que eu for.
Google Apps (Gmail) Não sei qualificar quantos % da minha vida profissional esta encima do Google Apps, mas sei que tem muita coisa lá.

Agora para seguir com o meme, convido meus amigos:
Christiano Anderson
Bruno Rocha
Bernardo Heynemann
Rodrigo Bernardo Pimentel

Curso Desenvolvimento ágil com Django

avelino@chierry.com (avelino) — Thu, 27 Jan 2011 15:11:45 -0600

Comece a desenvolver com um framework de alto nível, que estimula o desenvolvimento rápido e limpo. Aprenda Django agora!

O Curso esta no valor de R$ 69,00.

No curso explico como fazer um site completo com Django onde contemplo valores que o profissional vai usar no desenvolvimento de sistemas, no curso tem materiais suficiente para que você possa criar e ajuda qual quer projeto Open Source escrito em Python e Django.

O curso esta sendo realizado com apoio do iMasters Pro onde temos outros curso com uma qualidade excelente.

Veja o conteudo do curso de Django no site do iMasters Pro.