Aspas duplas em arquivos batch (.bat)

Se por um acaso do destino você precisar alterar ou começar do zero um arquivo batch (.bat) e ainda necessitar receber argumentos pela chamada do arquivo, muito provavelmente você irá utilizar aspas no argumento se ele for um caminho de alguma pasta ou diretório.

Se esse caminho não possuir espaços, tudo será tranquilo, você provavelmente irá utilizar %1 e receberá o argumento corretamente, mas se o caminho possuir espaços, você vai colar aspas duplas pra passar o parâmetro corretamente e surpresa não vai conseguir concatenar esse caminho com nada.

Depois de muita pesquisa do google fica a dica então: %~1 retira as aspas do caminho facilitando para você fazer algo do tipo:

"%~1\programa.exe"

Lembrando que segundo a fonte isso vale apenas para NT 4 (SP6) pra cima.

Fonte: http://www.robvanderwoude.com/parameters.php

Debugando no Django com winpdb

Continuando o post anterior[1], além do pdb[2] que é totalmente via linha de comando, há o winpdb[3] que possui uma interface gráfica para facilitar a depuração.

Instalá-lo é muito fácil, se você possui easy_install é só executar:

sudo easy_install winpdb

Se você não tem easy_install, mas tem apt-get:

sudo apt-get install winpdb

Se você não tem nada disso ainda dá pra baixar pelo site[3] e funciona no Windows também, mas eu não testei.

Usarei como exemplo o código criado pelo post anterior, é um projeto bem simples com apenas uma view para atestar o poder do debug.

Lembra da nossa view, ela é simples assim:

def hello(request):
    a = 2
    b = 3
    c = [1,2,3]
    c.pop()
    d = soma(3,4)
    response = HttpResponse("Hello World")
    return response

Como o winpdb possui a funcionalidade de adicionar breakpoints eu tirei aquele código de debug do pdb senão eles conflitariam entre si.

Abra o winpdb:

winpdb

A interface dele é bem simples, ficará mais clara quando estivermos executando alguma coisa.

Vá até File->Launch e na janela aberta escolha o manage.py do projeto que vamos depurar, por fim adicione runserver --noreload no comando e então clique em OK para iniciar o servidor.

O seu winpdb deve ficar parecido com a imagem abaixo, além de um terminal que será aberto pelo próprio winpdb.

winpdb executando django runserver --noreload

Antes de continuar qualquer coisa, vá até File->Open Source e na janela aberta escolha o arquivo views.py, adicione um breakpoint na linha a = 2 clicando à direita do número da linha. Tente acessar a URL que executa a view hello e volte ao winpdb, você verá algo como abaixo (a diferença é que eu já andei duas linhas no código):

winpdb na view hello

Essa imagem é bem interessante pois mostra valores das variáveis, um console escondido abaixo do código, o arquivo em que o debugger se encontra, controles de avanço do debug, etc.

Avance com Control->Next até a chamada de soma e entre com Control->Step Into, avance duas linhas e você ficará assim:

winpdb na função soma

As variáveis do escopo local mudaram, o debugger continua no views.py mas agora dentro da função soma, dê Control->Return para ir até antes da função retornar pro escopo de hello.

Com Control->Next vá até antes da linha que executa return response e vamos brincar um pouco com o console que se encontra abaixo do código-fonte:

winpdb e o console

Como você pode ver na imagem, o comando v (de eval) seguido de uma expressão retorna o valor da expressão, já o comando x (de exec) seguido de uma expressão executa a expressão informada.

Vamos fazer igual ao post anterior e verificar as propriedades de response:

winpdb e o console alterando a response

Na imagem acima, executamos um dir na variável response, exibimos seu content com v, alteramos o content com x e por fim com Control->Go visualizamos o resultado no navegador:

resultado final no navegador

Para saber de mais funcionalidades que o winpdb pode te oferecer dê uma olhada no tutorial[4] (bem completo por sinal) que se encontra na própria wiki[5] deles.

[1] – http://blog.danilocabello.com/arquivo/debugando-no-django/ [2] – http://docs.python.org/library/pdb.html [3] – http://winpdb.org/ [4] – http://winpdb.org/cgi-bin/moin.cgi/WinpdbTutorial [5] – http://winpdb.org/cgi-bin/moin.cgi/FrontPage

Debugando no Django

Bem que você tentou, releu o código diversas vezes, escreveu um monte de prints, mas não conseguiu descobrir o que está causando aquele bug indesejado. É chegada a hora de debugar seu código, a seguir darei algumas dicas de como debugar com pdb seu projeto em Django[1].

Primeiramente, debugar um projeto em Python[2] e debugar um projeto em Django não tem muita diferença, a coisa toda é muito parecida, você só precisa do pontapé inicial para se virar dali pra frente.

Para aprender como utilizar o pdb[3] (vulgo Python Debugger) crie um novo projeto chamado djdebug, logo em seguida crie um arquivo vazio chamado views.py na própria raiz do projeto, ficando com a seguinte estrutura de arquivos:

djdebug
  - init.py
  - manage.py
  - settings.py
  - urls.py
  - views.py

No arquivo views.py cole o seguinte código:

from django.shortcuts import HttpResponse</p>

<p>def soma(a,b):
    arg1 = a
    arg2 = b
    soma = arg1 + arg2
    return soma</p>

<p>def hello(request):
    a = 2
    b = 3
    c = [1,2,3]
    c.pop()
    d = soma(3,4)
    response = HttpResponse(&quot;Hello World&quot;)
    return response

Como podemos ver o arquivo contém uma função soma, que não faz nada de muito complexo e uma função hello que retorna uma response com o conteúdo "Hello World".

No arquivo urls.py importe a view hello e adicione uma URL para podemos acessá-la:

from views import hello</p>

<p>urlpatterns = patterns('',
    ...
    (r'^hello', hello),
)

Execute o servidor de testes, navegue até http://localhost:8000/hello e verifique que está tudo funcionando:

./manage runserver

Suponha que há um bug em alguma parte da view hello e então adicione o código para possibilitar o debug:

def hello(request):
    a = 2
    import pdb
    pdb.set_trace()
    ...

Apenas para esclarecer, o import pdb importa o Python debugger, já o pdb.set_trace() serve pra colocar um breakpoint no código, há maneiras de se colocar um breakpoint no código sem alterá-lo através do próprio pdb[3].

Execute o servidor de testes mas desta vez adicione o parâmetro necessário para evitar recarregamento automático do código-fonte:

./manage runserver --noreload

Abra novamente a view hello no seu navegador, ela ficará parada e no terminal que você iniciou o servidor o pdb[3] estará parado esperando por comandos:

> /home/.../djdebug/views.py(13)hello()
-> b = 3
(Pdb) 

Vamos começar, temos um comando interessante que é o l (de list, lista o código na região do debugger) que lista onde se encontra o debugger:

(Pdb) l
  8<br />
  9     def hello(request):
 10         a = 2
 11         import pdb
 12         pdb.set_trace()
 13      -&gt;  b = 3
 14         c = [1,2,3]
 15         c.pop()
 16         d = soma(3,4)
 17         response = HttpResponse(&quot;Hello World&quot;)
 18         return response

É importante notar que o debugger se encontra no exato momento antes de executar a linha apontada pela seta, isto é, se executarmos p (de print, imprime a expressão passada como argumento) para inspecionarmos a variável b, ela não estará definida:

(Pdb) p a
2
(Pdb) p b
*** NameError: NameError("name 'b' is not defined",)

Vamos para próxima linha com n (de next, segue para a próxima linha):

(Pdb) n
> /home/.../djdebug/views.py(14)hello()
-> c = [1,2,3]
(Pdb) p b
3

Agora sim b já possui valor, vamos avançar até a chamada da função somar:

(Pdb) n
> /home/.../djdebug/views.py(15)hello()
-> c.pop()
(Pdb) <enter>
> /home/.../djdebug/views.py(16)hello()
-> d = soma(3,4)

A partir do primeiro n, enter executará n novamente. Como nós não sabemos se o problema da view hello é a função somar, vamos entrar na função somar com s (de step into, entra na função, ou seja, passo a dentro) e verificar se está tudo certo:

(Pdb) s
--Call--
&gt; /home/.../djdebug/views.py(3)soma()
-&gt; def soma(a,b):
(Pdb) l
  1       from django.shortcuts import HttpResponse
  2<br />
  3     -&gt; def soma(a,b):
  4           arg1 = a
  5           arg2 = b
  6           soma = arg1 + arg2
  7           return soma
  8<br />
  9       def hello(request):
 10           a = 2
 11           import pdb

Como podemos ver o debugger se encontra na entrada da função soma, damos uma “olhada por cima” e saímos da função com up (de up, sobe uma chamada na pilha):

> /home/.../djdebug/views.py(4)soma()
-> arg1 = a
(Pdb) n
> /home/.../djdebug/views.py(5)soma()
-> arg2 = b
(Pdb) n
> /home/.../djdebug/views.py(6)soma()
-> soma = arg1 + arg2
(Pdb) u
> /home/.../djdebug/views.py(16)hello()
-> d = soma(3,4)

Como podemos ver, voltamos a view hello, vamos avançar até antes de retornar a resposta da requisição e atestar umas coisinhas:

(Pdb) n
&gt; /home/.../djdebug/views.py(17)hello()
-&gt; response = HttpResponse(&quot;Hello World&quot;)
(Pdb) n
&gt; /home/.../djdebug/views.py(18)hello()
-&gt; return response
(Pdb) dir(response)
['<strong>class</strong>', '<strong>contains</strong>', '<strong>delattr</strong>', '<strong>delitem</strong>', '<strong>dict</strong>', '<strong>doc</strong>', '<strong>format</strong>', '<strong>getattribute</strong>', '<strong>getitem</strong>', '<strong>hash</strong>', '<strong>init</strong>', '<strong>iter</strong>', '<strong>module</strong>', '<strong>new</strong>', '<strong>reduce</strong>', '<strong>reduce_ex</strong>', '<strong>repr</strong>', '<strong>setattr</strong>', '<strong>setitem</strong>', '<strong>sizeof</strong>', '<strong>str</strong>', '<strong>subclasshook</strong>', '<strong>weakref</strong>', '_charset', '_container', '_convert_to_ascii', '_get_content', '_headers', '_is_string', '_set_content', 'close', 'content', 'cookies', 'delete_cookie', 'flush', 'get', 'has_header', 'items', 'next', 'set_cookie', 'status_code', 'tell', 'write']
(Pdb) response.content
'Hello World'
(Pdb) response.content = 'Django debugado'
(Pdb) c

Como podemos verificar, o pdb[3] fornece um shell do Python[2] você pode executar dir, verificar valores de variáveis e até mudar conteúdo de variáveis (poder e perigo andando juntos), por fim executamos c (de continue, para continuar a execução), veja o resultado no seu navegador, a mensagem "Hello World" foi trocada por "Django debugado".

Recomendo a leitura do paper “Debugging in Python”[4] para mais alguns detalhes do pdb[3]. É muito interessante saber “brincar” com o shell do Python e do Django, com essas ferramentas fica mais fácil rastrear o chato do bug.

[1] - http://www.djangoproject.com/ [2] – http://www.python.org/ [3] – http://docs.python.org/library/pdb.html [4] – http://www.ferg.org/papers/debugging_in_python.html

django-registration faciltando o cadastro de usuários

Estava procurando por uma forma de bloquear e-mails duplicados no django.contrib.auth[1], eis que encontro o projeto “plugável” django-registration[2] que não só implementa essa funcionalidade como e-mails de confirmação e a confirmação ainda expira conforme um número de dias definido nas suas settings.py.

A aplicação é muito completa, possui testes e exige o mínimo de conhecimento em Django que é saber criar templates. Ao baixar a aplicação eu pensei que iria ter que adaptar um monte de coisa para se encaixar na minha aplicação, que nada, a aplicação está no limite da plugabilidade que o Django investe.

Give a try.

[1] – http://docs.djangoproject.com/en/dev/topics/auth/#topics-auth [2] – http://bitbucket.org/ubernostrum/django-registration/

Scripts Python com optparse

Dica rápida, se você costuma usar Python para fazer scripts e toda vez que vai reutilizar um deles tem que olhar o código fonte pra lembrar como usar, você precisa conhecer o optparse[1].

Dê uma olhada na documentação[1], que é bem completa e no exemplo abaixo, para ver o quão prático é utilizar este módulo.

def fatorial(n):
    resultado = 1
    while n &gt; 0:
        resultado = n*resultado
        n -= 1
    return resultado</p>

<p>if <strong>name</strong> == '<strong>main</strong>':
    from optparse import OptionParser
    parser = OptionParser()
    parser.add_option('-a', '--arquivo', 
                      dest='arquivo', help='arquivo com os fatoriais desejados')
    parser.add_option('-v', '--valor', type='int', 
                      dest='valor', help='valor a ser calculado')
    (options, args) = parser.parse_args()</p>

<pre><code>if options.valor and options.arquivo:
    parser.error(&amp;quot;opcoes -v e -a sao mutualmente exclusivas&amp;quot;)
elif options.valor:
    print &amp;quot;fatorial(%s) = %s&amp;quot; % (options.valor, fatorial(options.valor))
elif options.arquivo:
    for linha in open(options.arquivo):
        linha = int(linha)
        print &amp;quot;fatorial(%s) = %s&amp;quot; % (linha, fatorial(linha))
else:
    parser.error(&amp;quot;nenhuma opcao foi escolhida, execute com -h para ajuda&amp;quot;)
</code></pre>

<p>

[1] – http://docs.python.org/library/optparse.html