vulture
2.14 (2024-12-08)
Vulture encuentra código no utilizado en programas Python. Esto es útil para limpiar y encontrar errores en bases de código grandes. Si ejecuta Vulture tanto en su biblioteca como en su conjunto de pruebas, puede encontrar código no probado.
Debido a la naturaleza dinámica de Python, es probable que los analizadores de código estático como Vulture pasen por alto algún código muerto. Además, el código que sólo se llama implícitamente puede informarse como no utilizado. No obstante, Vulture puede ser una herramienta muy útil para obtener un código de mayor calidad.
--sort-by-size $ pip install vulture
$ vulture myscript.py # or
$ python3 -m vulture myscript.py
$ vulture myscript.py mypackage/
$ vulture myscript.py --min-confidence 100 # Only report 100% dead code.
Los argumentos proporcionados pueden ser archivos o directorios de Python. Para cada directorio, Vulture analiza todos los archivos *.py contenidos.
Una vez que haya encontrado y eliminado el código inactivo, ejecute Vulture nuevamente, ya que puede descubrir más código inactivo.
Además de encontrar funciones, clases, etc. no utilizadas, Vulture puede detectar código inalcanzable. A cada fragmento de código inactivo se le asigna un valor de confianza entre el 60% y el 100%, donde un valor del 100% indica que es seguro que el código no se ejecutará. Los valores por debajo del 100 % son estimaciones muy aproximadas (según el tipo de fragmento de código) de la probabilidad de que el código no se utilice.
| Tipo de código | Valor de confianza |
|---|---|
| función/método/argumento de clase, código inalcanzable | 100% |
| importar | 90% |
| atributo, clase, función, método, propiedad, variable | 60% |
Puede utilizar el indicador --min-confidence para establecer la confianza mínima para que el código se informe como no utilizado. Utilice --min-confidence 100 para informar únicamente el código que se garantiza que no se utilizará dentro de los archivos analizados.
Cuando Vulture informa incorrectamente que fragmentos de código no se utilizan, tiene varias opciones para suprimir los falsos positivos. Si corregir sus falsos positivos también podría beneficiar a otros usuarios, presente un informe de problema.
La opción recomendada es agregar código usado que se informa como no utilizado a un módulo de Python y agregarlo a la lista de rutas escaneadas. Para obtener dicha lista blanca automáticamente, pase --make-whitelist a Vulture:
$ vulture mydir --make-whitelist > whitelist.py
$ vulture mydir whitelist.py
Tenga en cuenta que el archivo whitelist.py resultante contendrá una sintaxis válida de Python, pero para que Python pueda ejecutarlo , normalmente deberá realizar algunas modificaciones.
Recopilamos listas blancas para módulos y paquetes comunes de Python en vulture/whitelists/ (las solicitudes de extracción son bienvenidas).
Si desea ignorar un archivo o directorio completo, utilice el parámetro --exclude (por ejemplo, --exclude "*settings.py,*/docs/*.py,*/test_*.py,*/.venv/*.py" ). Los patrones de exclusión se comparan con rutas absolutas.
Para compatibilidad con flake8, Vulture admite los códigos de error F401 y F841 para ignorar importaciones no utilizadas ( # noqa: F401 ) y variables locales no utilizadas ( # noqa: F841 ). Sin embargo, recomendamos utilizar listas blancas en lugar de comentarios noqa , ya que los comentarios noqa añaden ruido visual al código y lo hacen más difícil de leer.
Puedes usar --ignore-names foo*,ba[rz] para permitir que Vulture ignore todos los nombres que comienzan con foo y los nombres bar y baz . Además, la opción --ignore-decorators se puede utilizar para ignorar los nombres de las funciones decoradas con el decorador dado (pero no sus argumentos o el cuerpo de la función). Esto es útil, por ejemplo, en proyectos de Flask, donde puede usar --ignore-decorators "@app.route" para ignorar todos los nombres de funciones con el decorador @app.route . Tenga en cuenta que Vulture simplifica los decoradores que no puede analizar: @foo.bar(x, y) se convierte en "@foo.bar" y @foo.bar(x, y).baz se convierte en "@" internamente.
Recomendamos usar listas blancas en lugar de --ignore-names o --ignore-decorators siempre que sea posible, ya que las listas blancas se verifican automáticamente para determinar su corrección sintáctica cuando se pasan a Vulture y, a menudo, incluso puede pasarlas a su intérprete de Python y dejar que verifique que todas las listas blancas están en la lista blanca. El código realmente todavía existe en su proyecto.
Hay situaciones en las que no se pueden simplemente eliminar variables no utilizadas, por ejemplo, en firmas de funciones. La solución recomendada es utilizar la palabra clave del como se describe en el manual de PyLint y en StackOverflow:
def foo ( x , y ):
del y
return x + 3 Vulture también ignorará todas las variables que comiencen con un guión bajo, por lo que puede usar _x, y = get_pos() para marcar asignaciones de tuplas o argumentos de funciones no utilizados, por ejemplo, def foo(x, _y) .
Aumente el valor mínimo de confianza con la bandera --min-confidence .
Si Vulture se queja de un código como if False: , puedes usar un indicador booleano debug = False y escribir if debug: en su lugar. Esto hace que el código sea más legible y silencia a Vulture.
Véase el n.º 216. Por ejemplo, en lugar de def foo(arg: "Sequence"): ... , recomendamos usar
from __future__ import annotations
def foo ( arg : Sequence ):
... También puede almacenar argumentos de línea de comando en pyproject.toml en la sección tool.vulture . Simplemente elimine los guiones iniciales y reemplace todos los guiones restantes con guiones bajos.
Las opciones proporcionadas en la línea de comando tienen prioridad sobre las opciones en pyproject.toml .
Configuración de ejemplo:
[ tool . vulture ]
exclude = [ " *file*.py " , " dir/ " ]
ignore_decorators = [ " @app.route " , " @require_* " ]
ignore_names = [ " visit_* " , " do_* " ]
make_whitelist = true
min_confidence = 80
paths = [ " myscript.py " , " mydir " , " whitelist.py " ]
sort_by_size = true
verbose = true Vulture buscará automáticamente un pyproject.toml en el directorio de trabajo actual.
Para usar un pyproject.toml en otro directorio, puede usar el indicador --config path/to/pyproject.toml .
Puede utilizar un gancho de confirmación previa para ejecutar Vulture antes de cada confirmación. Para esto, instale pre-commit y agregue lo siguiente al archivo .pre-commit-config.yaml en su repositorio:
repos :
- repo : https://github.com/jendrikseipp/vulture
rev : ' v2.3 ' # or any later Vulture version
hooks :
- id : vulture Luego ejecute pre-commit install . Finalmente, cree un archivo pyproject.toml en su repositorio y especifique todos los archivos que Vulture debe verificar en [tool.vulture] --> paths (ver arriba).
También hay una acción de GitHub para Vulture y puedes usar Vulture programáticamente. Por ejemplo:
import vulture
v = vulture . Vulture ()
v . scavenge ([ '.' ])
unused_code = v . get_unused_code () # returns a list of `Item` objects Vulture utiliza el módulo ast para crear árboles de sintaxis abstracta para todos los archivos proporcionados. Mientras recorre todos los árboles de sintaxis, registra los nombres de los objetos definidos y utilizados. Luego, informa los objetos que han sido definidos, pero no utilizados. Este análisis ignora los ámbitos y solo tiene en cuenta los nombres de los objetos.
Vulture también detecta código inalcanzable buscando código después de las declaraciones return , break , continue y raise , y buscando condiciones if y while insatisfactorias.
Cuando se utiliza la opción --sort-by-size , Vulture ordena el código no utilizado por su número de líneas. Esto ayuda a los desarrolladores a priorizar dónde buscar primero el código inactivo.
Considere el siguiente script de Python ( dead_code.py ):
import os
class Greeter :
def greet ( self ):
print ( "Hi" )
def hello_world ():
message = "Hello, world!"
greeter = Greeter ()
func_name = "greet"
greet_func = getattr ( greeter , func_name )
greet_func ()
if __name__ == "__main__" :
hello_world ()Llamando:
$ vulture dead_code.py
da como resultado el siguiente resultado:
dead_code.py:1: unused import 'os' (90% confidence)
dead_code.py:4: unused function 'greet' (60% confidence)
dead_code.py:8: unused variable 'message' (60% confidence)
Vulture informa correctamente os y message no se utilizan, pero no detecta que realmente se utiliza greet . El método recomendado para lidiar con falsos positivos como este es crear un archivo Python de lista blanca.
Preparando listas blancas
En una lista blanca simulamos el uso de variables, atributos, etc. Para el programa anterior, una lista blanca podría tener el siguiente aspecto:
# whitelist_dead_code.py
from dead_code import Greeter
Greeter . greet Alternativamente, puede pasar --make-whitelist a Vulture y obtener una lista blanca generada automáticamente.
Pasar tanto el programa original como la lista blanca a Vulture
$ vulture dead_code.py whitelist_dead_code.py
hace que Vulture ignore el método greet :
dead_code.py:1: unused import 'os' (90% confidence)
dead_code.py:8: unused variable 'message' (60% confidence)
| código de salida | Descripción |
|---|---|
| 0 | No se encontró ningún código muerto |
| 1 | Entrada no válida (falta archivo, error de sintaxis, codificación incorrecta) |
| 2 | Argumentos de línea de comando no válidos |
| 3 | Código muerto encontrado |
Visite https://github.com/jendrikseipp/vulture para informar cualquier problema o realizar solicitudes de extracción.
