Ferramenta para converter o código Python para ser compatível com PEP8

Eu sei que existem ferramentas que validam se o seu código Python é compatível com PEP8, por exemplo, há um serviço online e um módulo python .

No entanto, não consigo encontrar um serviço ou módulo que possa converter meu arquivo Python em um arquivo Python válido PEP8 independente. Alguém sabe se existe algum?
Presumo que seja viável, já que o PEP8 tem tudo a ver com a aparência do código, certo?

Infelizmente, "pep8 storming" (todo o projeto) tem vários efeitos colaterais negativos:

• muitos conflitos de fusão
• quebrar a culpa
• tornar a revisão do código difícil

Como alternativa (e graças a @yp pela ideia ), escrevi um pequeno pacote que autopep8s apenas as linhas nas quais você trabalhou desde o último commit / branch:

Basicamente, deixando o projeto um pouco melhor do que o encontrou :

pip install pep8radius

Suponha que você tenha feito seu trabalho mastere esteja pronto para se comprometer:

# be somewhere in your project directory
# see the diff with pep, see the changes you've made since master
pep8radius master --diff
# make those changes
pep8radius master --diff --in-place

Ou para limpar as novas linhas que você cometeu desde o último commit:

pep8radius --diff
pep8radius --diff --in-place

# the lines which changed since a specific commit `git diff 98f51f`
pep8radius 98f51f --diff

Basicamente, pep8radiusé aplicar autopep8 às linhas na saída de git / hg diff (do último commit compartilhado ).

Este script atualmente funciona com git e hg, se você estiver usando outra coisa e quiser que isso funcione , poste um comentário / problema / PR !

Você pode usar o autopep8 ! Enquanto você faz uma xícara de café, esta ferramenta felizmente remove todas as violações do PEP8 que não mudam o significado do código.

Instale-o via pip:

pip install autopep8

Aplique isso a um arquivo específico:

autopep8 py_file --in-place

ou para o seu projeto (recursivamente), a opção detalhada fornece algum feedback de como está indo :

autopep8 project_dir --recursive --in-place --pep8-passes 2000 --verbose

Nota: Às vezes, o padrão de 100 passes não é suficiente, eu o defino para 2.000, pois é razoavelmente alto e pegará todos os arquivos, exceto os mais problemáticos (ele para de passar quando não encontra infrações pep8 resolvíveis) ...

Nesse ponto, sugiro testar novamente e fazer um commit!

Se você quiser conformidade PEP8 "total" : uma tática que usei é executar o autopep8 como acima e, em seguida, executar o PEP8, que exibe as violações restantes (arquivo, número da linha e o que):

pep8 project_dir --ignore=E501

e altere-os individualmente (por exemplo, E712s - comparação com booleano).

Nota: autopep8 oferece um --aggressiveargumento (para "consertar" impiedosamente essas violações de mudança de significado), mas cuidado se você usar agressivo, você pode ter que depurar ... (por exemplo, em numpy / pandas, True == np.bool_(True)mas não True is np.bool_(True)!)

Você pode verificar quantas violações de cada tipo (antes e depois):

pep8 --quiet --statistics .

Nota: Eu considero E501s (linha muito longa) são um caso especial, pois provavelmente haverá muitos deles em seu código e às vezes não são corrigidos pelo autopep8.

Como exemplo, apliquei essa técnica à base de código do pandas .

@Andy Hayden deu uma boa visão geral do autopep8. Além disso, há mais um pacote chamado pep8ify que também faz a mesma coisa.

No entanto, ambos os pacotes podem remover apenas erros de lint, mas não podem formatar o código.

little = more[3:   5]

O código acima permanece o mesmo após a pep8ificação também. Mas o código ainda não parece bom. Você pode usar formatadores como yapf , que formatará o código mesmo se o código for compatível com PEP8. O código acima será formatado para

little = more[3:5]

Algumas vezes, isso até destrói sua formatação manual. Por exemplo

BAZ = {
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
}

será convertido para

BAZ = {[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]}

Mas você pode dizer a ele para ignorar algumas partes.

BAZ = {
   [1, 2, 3, 4],
   [5, 6, 7, 8],
   [9, 10, 11, 12]
}  # yapf: disable

Retirado de minha antiga postagem no blog: Automaticamente PEP8 e formate seu código Python!

Se você estiver usando o eclipse + PyDev, você pode simplesmente ativar o autopep8 nas configurações do PyDev: Windows -> Preferências -> digite 'autopep8' no filtro de pesquisa.

Verifique o 'use autopep8.py para formatação de código?' -> OK

Agora, a formatação de código CTRL-SHIFT-F do eclipse deve formatar seu código usando autopep8 :)

Fiz uma ampla pesquisa sobre diferentes instrumentos para python e estilo de código. Existem dois tipos de instrumentos: linters - analisando seu código e dando alguns avisos sobre estilos de código mal usados ​​e mostrando conselhos sobre como corrigi-lo, e formatadores de código - quando você salva seu arquivo, ele reformata seu documento usando o estilo PEP.

Porque a reformatação deve ser mais precisa - se remorfat algo que você não quer que se torne inútil - eles cobrem menos parte do PEP, os linters mostram muito mais.

Todos eles têm diferentes permissões de configuração - por exemplo, pylinter configurável em todas as suas regras (você pode ligar / desligar todos os tipos de avisos), preto não configurável em tudo.

Aqui estão alguns links e tutoriais úteis:

Documentação:

• PEP-257 Docstring Conventions: https://www.python.org/dev/peps/pep-0257/
• PEP-484 Dica de tipo: https://www.python.org/dev/peps/pep-0484
• Guia de estilo do Chromium https://chromium.googlesource.com/chromiumos/docs/+/master/styleguide/python.md
• Estilo de código para autoteste https://chromium.googlesource.com/chromiumos/third_party/autotest/+/master/docs/coding-style.md
• Guia de estilo de codificação da Khan Academy https://github.com/Khan/style-guides/blob/master/style/python.md
• O guia do carona para Python https://docs.python-guide.org/
• Guia de estilo do EdX Python https://edx.readthedocs.io/projects/edx-developer-guide/en/latest/style_guides/python-guidelines.html
• Artigo de estilo de código no RealPython https://realpython.com/python-pep8/

Linters (em ordem de popularidade):

• mypy https://github.com/python/mypy linter para verificações de tipo (PEP-484)
• pycodestyle https://github.com/PyCQA/pycodestyle - bom usando PEP-8, muito popular. Freqüentemente usado ao lado do pylint e flake8 (simultaneamente)
• pylint https://github.com/PyCQA/pylint muito configurável, com suporte ativo
• bandit https://github.com/PyCQA/bandit линтер по безопасности
• prospector https://github.com/PyCQA/prospector pylint + verificação de dificuldade do código
• flake8 https://github.com/PyCQA/flake8 wrapper pycodestyle com capacidade de ativar plug-ins. Lista muito grande de diferentes plug-ins configuráveis. Aqui está o repo flake8 incrível: https://github.com/DmytroLitvinov/awesome-flake8-extensions
• wemake https://github.com/wemake-services/wemake-python-styleguide - tentando combinar muitos linters diferentes em um projeto (na verdade, é um plugin flake8 combinando estilos de vários outros linters)
• pylama https://github.com/klen/pylama tentando combinar 10 outros linters em um (mypy, pylint, pycodeestyle, pydocstyle и др.). Posso ver o único problema aqui - versão antiga (sem atualizações no repo do github por cerca de 10 meses).
• pydocstyle https://github.com/PyCQA/pydocstyle docstrings linter (PEP-257)

Formatadores de código (em ordem de popularidade):

• preto https://github.com/psf/black formatador mais popular, usado em várias grandes empresas. Foi criado depois do yapf, mas já tem mais inícios no GitHub
• yapf https://github.com/google/yapf formatador de código do Google
• autopep8 https://github.com/hhatto/autopep8 baseado no pycodestyle

Há muitos.

IDEs geralmente têm algum recurso de formatação embutido. IntelliJ Idea / PyCharm tem, o mesmo vale para o plug-in Python para Eclipse e assim por diante.

Existem formatadores / linters que podem ser direcionados a vários idiomas. https://coala.io é um bom exemplo disso.

Depois, há as ferramentas de propósito único, das quais muitas são mencionadas em outras respostas.

Um método específico de reformatação automática é analisar o arquivo na árvore AST (sem descartar comentários) e, em seguida, despejá-lo de volta no texto (o que significa que nada da formatação original é preservado). Um exemplo disso seria https://github.com/python/black .