Como depurar em Django, da boa maneira? [fechado]

É claro que só deve executar isto localmente, dado que dá a qualquer pessoa com um navegador os direitos de executar um código python arbitrário no contexto do servidor.

Uma pequena rapidinha para marcas de modelos:

@register.filter 
def pdb(element):
    import pdb; pdb.set_trace()
    return element

Agora, dentro de um modelo, poderá fazer {{ template_var|pdb }} e introduzir uma sessão do pdb (dado que está a correr o servidor de devel local) onde poderá inspeccionar element o conteúdo do seu coração.

O mais importante é a barra de depuração do Django .

Então você precisa de um bom registo usando a instalação Python logging. Você pode enviar o resultado do registo para um ficheiro de registo, mas uma opção mais fácil é enviar o resultado do registo para firepython. Para usar isto, terá de usar o navegador Firefox com a extensão firebug. O Firepython inclui um plugin firebug que irá mostrar qualquer registo do lado do Servidor numa página do Firebug.

O Firebug em si também é fundamental para depurar o lado Javascript de qualquer aplicação que desenvolva. (Assumindo que você tem algum código JS, é claro).

Eu também gostava dedjango-viewtools para depurar visualizações interactivamente usando o pdb, mas não o uso muito.

Existem ferramentas mais úteis como dozer para rastrear vazamentos de memória (há também outras boas sugestões dadas em Respostas aqui em SO para rastreamento de memória).

Eu uso PyCharm (o mesmo motor pydev que o eclipse). Realmente me ajuda a ser visualmente capaz de passar através do meu código e ver o que está acontecendo.

Quase tudo foi mencionado até agora, então eu só vou adicionar que em vez de {[[0]} pode-se usar ipdb.set_trace () que usa o iPython e, portanto, é mais poderoso (autocompleto e outros bens). Isso requer pacote ipdb, então você só precisa pip install ipdb

Eu empurrei {[[2]} Para PyPI . É um aplicativo simples que significa que você não precisa editar seu código fonte cada vez que você quer quebrar no pdb.

1. pip install django-pdb
2. adicionar 'django_pdb' ao seu INSTALLED_APPS

Agora Pode correr: manage.py runserver --pdb para entrar no pdb no início de cada Vista...

bash: manage.py runserver --pdb
Validating models...

0 errors found
Django version 1.3, using settings 'testproject.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

GET /
function "myview" in testapp/views.py:6
args: ()
kwargs: {}

> /Users/tom/github/django-pdb/testproject/testapp/views.py(7)myview()
-> a = 1
(Pdb)

E executar: manage.py test --pdb para entrar no pdb sobre falhas/erros de teste...

bash: manage.py test testapp --pdb
Creating test database for alias 'default'...
E
======================================================================
>>> test_error (testapp.tests.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File ".../django-pdb/testproject/testapp/tests.py", line 16, in test_error
    one_plus_one = four
NameError: global name 'four' is not defined
======================================================================

> /Users/tom/github/django-pdb/testproject/testapp/tests.py(16)test_error()
-> one_plus_one = four
(Pdb)

O projecto está hospedado em GitHub , as contribuições são bem-vindas, é claro.

A maneira mais fácil de depurar python - especialmente para programadores que são usados no Visual Studio - é usando PTVS (Python Tools for Visual Studio). Os passos são simples:

1. Descarregue e instale a partir de http://pytools.codeplex.com/
2. Definir pontos de paragem e carregar em F5.
3. se o seu ponto de paragem for atingido, poderá ver/alterar as variáveis tão facilmente como depurar programas C#/C++.
É tudo.

Se quiser depurar o Django usando o PTVS, você necessidade de fazer o seguinte:

1. na configuração do projecto-página Geral, configure o "ficheiro inicial" para "manage.py", o ponto de entrada do programa Django.
2. na página Configuração do projecto-depuração, defina "argumentos do programa"como" runserver --noreload". O ponto chave é o" -- noreload " aqui. Se não o definir, os seus pontos de paragem não serão atingidos.
Aproveita.

Eu uso o pyDev com o Eclipse muito bom, definir pontos de paragem, avançar para o Código, ver valores em quaisquer objectos e variáveis, experimente.

USOo PyCharm e mantenho-o sempre. Custou-me um pouco, mas devo dizer que a vantagem que tenho é inestimável. Eu tentei depurar a partir do console e eu dou às pessoas um monte de crédito que pode fazer isso, mas para mim ser capaz de depurar visualmente Meu(s) Aplicativo (s) é ótimo.

Na minha perspectiva, poderíamos decompor tarefas comuns de depuração de códigos em três padrões de utilização distintos:

Alguma coisa abriu uma excepção.: runserver_plus ' depurador Werkzeug para salvamento. A capacidade de executar código personalizado em todos os níveis de rastreamento é um assassino. E se você estiver completamente preso, você pode criar um Gist para compartilhar com apenas um clique.
1. a página é renderizada, mas o resultado está errado: mais uma vez, as rochas de Werkzeug. Para fazer um ponto de paragem em código, basta escrever assert False no local onde quer parar.
2. O código funciona mal, mas o olhar rápido não ajuda. Provavelmente, um problema algorítmico. Suspiro. Então eu normalmente acendo um depurador de consola PuDB: import pudb; pudb.set_trace(). A principal vantagem sobre o pdb [I] é que o PDB (ao olhar como você está nos anos 80) faz com que a configuração personalizada de expressões de relógio seja uma brisa. E depurar um monte de laços aninhados é muito mais simples com uma interface gráfica.

Às vezes, quando quero explorar um método em particular e invocar o pdb é demasiado complicado, eu acrescentaria:

import IPython; IPython.embed()

IPython.embed() inicia um shell IPython que tem acesso às variáveis locais a partir do ponto em que você o chama.

Recomendo vivamente o epdb (Extended Python Debugger).

Https://bitbucket.org/dugan/epdb

Uma coisa que eu adoro no epdb para depurar o Django ou outros webservers Python é o epdb.servir () comando. Isto define um traço e serve isto num porto local a que se pode ligar. Caso de Utilização típico:

import epdb; epdb.serve()

In [2]: import epdb; epdb.connect()
(Epdb) request
<WSGIRequest
path:/foo,
GET:<QueryDict: {}>, 
POST:<QuestDict: {}>,
...
>
(Epdb) request.session.session_key
'i31kq7lljj3up5v7hbw9cff0rga2vlq5'
(Epdb) list
 85         raise some_error.CustomError()
 86 
 87     # Example login view
 88     def login(request, username, password):
 89         import epdb; epdb.serve()
 90  ->     return my_login_method(username, password)
 91
 92     # Example view to show session key
 93     def get_session_key(request):
 94         return request.session.session_key
 95

E toneladas mais que você pode aprender sobre digitar ajuda epdb a qualquer momento.

Se quiser servir ou ligar-se a várias instâncias do epdb ao mesmo tempo, poderá indicar o porto onde ouvir (o valor por omissão é 8080). I. e.

import epdb; epdb.serve(4242)

>> import epdb; epdb.connect(host='192.168.3.2', port=4242)

A máquina é por omissão 'localhost' se não for indicada. Atirei-o para dentro. aqui para demonstrar como você pode usar isso para depurar algo diferente de uma instância local, como um servidor de desenvolvimento em sua LAN local. Obviamente, se você fizer isso, tenha cuidado para que o trace set nunca o faça em seu servidor de produção!

Como uma nota rápida, você ainda pode fazer a mesma coisa que a resposta aceita com o epdb (import epdb; epdb.set_trace()), mas eu queria destacar a funcionalidade de servir, uma vez que eu achei tão útil.

Também um artigo muito útil sobre depuradores de python: https://zapier.com/engineering/debugging-python-boss/

Finalmente , Se você gostaria de ver uma impressão gráfica de sua pilha de chamadas em Django, checkout: https://github.com/joerick/pyinstrument basta adicionar o pyinstrument.middleware.ProfilerMiddleware para MIDDLEWARE_CLASSES, em seguida, adicionar ?perfil ao final da URL de pedido para ativar o profiler.

Também pode executar o pyinstrument a partir da linha de comandos ou importando como um módulo.

USO PyCharm e diferentes ferramentas de depuração. Também ter um bom artigo sobre fácil configurar essas coisas para os noviços. Pode começar por aqui.Ele fala sobre depuração PDB e GUI em geral com projetos Django. Espero que alguém se beneficie deles.

Se usar o Aptana para o desenvolvimento do django, veja isto: http://www.youtube.com/watch?v=qQh-UQFltJQ

Caso contrário, considere usá-lo.

A maioria das opções já foram mencionadas. Para imprimir o contexto do modelo, criei uma biblioteca simples para isso. Ver https://github.com/edoburu/django-debugtools

Pode usá-lo para imprimir o contexto do modelo sem qualquer {% load %} construção:

{% print var %}   prints variable
{% print %}       prints all

Usa um formato de impressão digital personalizado para mostrar as variáveis numa marca <pre>.

Para aqueles que podem acidentalmente adicionar pdb em commits ao vivo, posso sugerir esta extensão da resposta #Koobz:

@register.filter 
def pdb(element):
    from django.conf import settings
    if settings.DEBUG:    
        import pdb
        pdb.set_trace()
    return element

O Wdb trabalha com o python 2 (2.6, 2.7), o python 3 (3.2, 3.3, 3.4, 3.5) e piroso. Ainda melhor, é possível depurar um programa python 2 com um servidor wdb rodando em python 3 e vice-versa ou depurar um programa rodando em um computador com um servidor de depuração rodando em outro computador dentro de uma página web em um terceiro computador! Mais ainda, é agora possível pausar um atualmente executando o processo/thread python usando a injeção de código da interface web. (Isto necessita do gdb e do ptrace activos) Em outras palavras, é uma versão muito melhorada do pdb diretamente em seu navegador com características agradáveis.

Instale e execute o servidor, e no seu código adicione:

import wdb
wdb.set_trace()

De acordo com o autor, As principais diferenças em relação a pdb são:

Para aqueles que não conhecem o projecto, o wdb é um depurador em python como o pdb, mas com uma web inteligente front-end e muitos recursos adicionais, tais como:

• realce de sintaxe do Código
• pontos de paragem visuais
• conclusão interactiva do código usando jedi
• pontos de paragem persistentes
• inspecção de objectos profundos utilizando o Suporte de Multithreading / multiprocessamento do rato
• depuração remota
• ver expressões
• na edição de código do depurador
• integração de servidores Web populares para quebrar o erro
• à excepção da quebra durante o rastreio (não após a morte), ao contrário do depurador de werkzeug, por exemplo
• a invadir programas actualmente em execução através de injecção de código (em sistemas suportados)

Tem uma grande interface de utilizador baseada no navegador. Uma alegria de usar! :)

Adicione import pdb; pdb.set_trace() na linha correspondente do código Python e execute-o. A execução vai parar com uma shell interativa. Na linha de comandos, poderá executar o código Python (ou seja, imprimir variáveis) ou usar comandos como:

• c continuar a execução
• n passo para a linha seguinte dentro da mesma função
• s passo para a linha seguinte nesta função ou uma função chamada
• q sai do depurador / execução

Também ver: https://poweruser.blog/setting-a-breakpoint-in-python-438e23fe6b28

Sugiro muito usar o PDB.

import pdb
pdb.set_trace()

Você pode inspecionar todos os valores das variáveis, entrar na função e muito mais. https://docs.python.org/2/library/pdb.html

Como mencionado em outros posts aqui - definir pontos de paragem em seu código e caminhar através do código para ver se ele se comporta como você esperava é uma ótima maneira de aprender algo como Django até que você tenha um bom senso de como tudo se comporta - e o que seu código está fazendo.

Também uso PyCharm - tem uma excelente análise de código estático e pode ajudar a detectar problemas antes de perceber que eles estão lá.

Como já mencionado django-debug-toolbar é essencial - https://github.com/django-debug-toolbar/django-debug-toolbar

E embora não seja explicitamente uma ferramenta de depuração ou análise - um dos meus favoritos é SQL Printing Middleware disponível a partir de excertos de Django em https://djangosnippets.org/snippets/290/

Isto irá mostrar as consultas SQL que a sua vista gerou. Isso lhe dará um bom senso do que o ORM está fazendo e se suas consultas são eficientes ou você precisa refazer o seu código (ou adicionar Cache).

Acho que é inestimável para manter um olho no desempenho da consulta durante o desenvolvimento e depuração da minha aplicação.

Apenas mais uma dica - eu modifiquei-a ligeiramente para o meu próprio uso apenas para mostrar o resumo e não o Declaração SQL.... Então eu sempre o uso enquanto desenvolvo e testo. Eu também adicionei isso se o len (conexão.consultas) é maior do que um limiar pré-definido que exibe um aviso extra.

Então se eu detectar algo ruim (a partir de uma performance ou de um número de perspectivas de consultas) está acontecendo, eu volto para trás na exibição completa das declarações SQL para ver exatamente o que está acontecendo. Muito útil quando você está trabalhando em um grande projeto Django com vários desenvolvedores.

Você pode alavancar nosetests e pdb juntos, em vez de injectar pdb.set_trace() manualmente nas suas vistas. A vantagem é que você pode observar as condições de erro quando eles começam pela primeira vez, potencialmente no código de terceiros.

TypeError at /db/hcm91dmo/catalog/records/

render_option() argument after * must be a sequence, not int

....


Error during template rendering

In template /opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/crispy_forms/templates/bootstrap3/field.html, error at line 28
render_option() argument after * must be a sequence, not int
18  
19          {% if field|is_checkboxselectmultiple %}
20              {% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
21          {% endif %}
22  
23          {% if field|is_radioselect %}
24              {% include 'bootstrap3/layout/radioselect.html' %}
25          {% endif %}
26  
27          {% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
28  

      {% if field|is_checkbox and form_show_labels %}

tests$ nosetests test_urls_catalog.py --pdb

Assim que eu atingir qualquer excepção (incluindo aqueles tratados graciosamente), o pdb pára onde isso acontece e eu posso olhar em volta.

  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/forms.py", line 537, in __str__
    return self.as_widget()
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/forms.py", line 593, in as_widget
    return force_text(widget.render(name, self.value(), attrs=attrs))
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py", line 513, in render
    options = self.render_options(choices, [value])
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py", line 543, in render_options
    output.append(self.render_option(selected_choices, *option))
TypeError: render_option() argument after * must be a sequence, not int
INFO lib.capture_middleware log write_to_index(http://localhost:8082/db/hcm91dmo/catalog/records.html)
INFO lib.capture_middleware log write_to_index:end
> /opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py(543)render_options()
-> output.append(self.render_option(selected_choices, *option))
(Pdb) import pprint
(Pdb) pprint.PrettyPrinter(indent=4).pprint(self)
<django.forms.widgets.Select object at 0x115fe7d10>
(Pdb) pprint.PrettyPrinter(indent=4).pprint(vars(self))
{   'attrs': {   'class': 'select form-control'},
    'choices': [[('_', 'any type'), (7, (7, 'type 7', 'RECTYPE_TABLE'))]],
    'is_required': False}
(Pdb)         

 'choices': [[('_', 'any type'), (7, (7, 'type 7', 'RECTYPE_TABLE'))]]

O mais fixe é que este pdb é tendo lugar dentro do Código do crispy, não o meu e não precisava de O inserir manualmente.

Utilizar pdb ou ipdb. Diffrence entre estes dois é ipdb suporta auto completo.

Para o pdb

import pdb
pdb.set_trace()

Para o ipdb

import ipdb
ipdb.set_trace()

Para executar a tecla new line hit n, para continuar a tecla c. verifique Mais opções usando help(pdb)

Durante o desenvolvimento, adicionando um rápido

assert False, value

Pode ajudar a diagnosticar problemas em pontos de vista ou em qualquer outro lugar, sem a necessidade de usar um depurador.

1. Usar o ipdb , que é um depurador melhorado gosta do pdb.

   import ipdb;ipdb.set_trace()

2. Usa a shell do django, usa apenas o comando abaixo. Isto é muito útil quando você está desenvolvendo uma nova visão.

   python manage.py shell