python abc

Python ABC

Una implementación de Python de la métrica de software ABC:

La métrica del software ABC fue introducido por Jerry Fitzpatrick en 1997 para superar los inconvenientes de la LOC. La métrica define una puntuación ABC como un triplete de valores que representan el tamaño de un conjunto de declaraciones de código fuente. Se calcula una puntuación ABC contando el número de tareas (a), el número de ramas (b) y el número de condicionales (c) en un programa. La puntuación ABC se puede aplicar a métodos, funciones, clases, módulos o archivos individuales dentro de un programa.

El artículo original de Fitzpatrick está, al momento de escribir, solo disponible a través de la máquina Wayback, por lo que también se incluye una copia en este repositorio.

El documento enumera las reglas de conteo para C, C ++ y Java, por lo que aquí están las reglas que usa este repositorio para Python:

• Agregue uno al recuento de tareas cuando:
  • Ocurrencia de un operador de asignación (excluyendo las asignaciones de parámetros predeterminadas).
• Agregue uno al recuento de ramas cuando:
  • Ocurrencia de una función de llamada/espera o una llamada de método de clase/espera.
  • Ocurrencia de una instancia de clase.
• Agregue uno al recuento de condiciones cuando:
  • Ocurrencia de un operador condicional.
  • Ocurrencia de las siguientes palabras clave: else , elif , except .
  • Ocurrencia de una declaración assert sin un operador condicional.

Uso

Instale los requisitos en su entorno virtual de elección, luego puede ver los argumentos de la línea de comandos que están disponibles:

$ python -m python_abc --help
usage: python_abc [-h] [--debug DEBUG] [--sort SORT] [--verbose VERBOSE] path

A python implementation of the ABC Software metric: https://en.wikipedia.org/wiki/ABC_Software_Metric

positional arguments:
  path               path to directory or file

optional arguments:
  -h, --help         show this help message and exit
  --debug DEBUG      display AST output for each element in the parsed tree
  --sort SORT        sort files from highest to lowest magnitude
  --verbose VERBOSE  display marked-up file

Dada file.py que contiene el siguiente texto:

 if a and b :
    print ( a )
else :
    print ( b )

a = sum ( i for i in range ( 1000 ) if i % 3 == 0 and i % 5 == 0 )

def f ( n ):
    def inner ( n ):
        return n ** 2
    if n == 0 :
        return 1
    elif n == 1 :
        return n
    elif n < 5 :
        return ( n - 1 ) ** 2
    return n * pow ( inner ( n ), f ( n - 1 ), n - 3 )

Puede obtener la salida de Barebones de la siguiente manera:

$ python -m python_abc /path/to/file.py
/path/to/file.py         < 1, 7, 10> (12.2)

Pasar la bandera verbose dará más detalle:

$ python -m python_abc file.py --verbose=true
cc    | if a and b:
b     |     print(a)
c     | else:
b     |     print(b)
      |
abbcc | a = sum(i for i in range(1000) if i % 3 == 0 and i % 5 == 0)
      |
      | def f(n):
      |     def inner(n):
      |         return n ** 2
c     |     if n == 0:
      |         return 1
cc    |     elif n == 1:
      |         return n
cc    |     elif n < 5:
      |         return (n - 1) ** 2
bbb   |     return n * pow(inner(n), f(n - 1), n - 3)
file.py          < 1, 7, 10> (12.2)

Si desea inspeccionar el árbol de sintaxis abstracto para el archivo, puede pasar el indicador debug , que imprimirá cada nodo desde el árbol y el vector que resultó de él.

El argumento path también puede ser una ruta a un directorio, en cuyo caso todos los archivos de Python en ese directorio (y sus subdirectorios) se escanearán, momento en el que puede ser útil pasar el indicador sort para clasificar los archivos por ABC magnitud:

$ python -m python_abc . --sort
./calculate.py                              < 18, 56, 23> (63.2)
./vector.py                                 < 12, 23, 11> (28.2)
./main.py                                    < 10, 23, 8> (26.3)
./tests/test_vector.py                       < 4, 19, 10> (21.8)
./tests/__init__.py                           < 4, 12, 1> (12.7)
./tests/test_radon_test_cases.py                < 1, 2, 1> (2.4)
./tests/test_calculate_condition.py             < 1, 2, 1> (2.4)
./tests/test_calculate_empty.py                 < 1, 2, 1> (2.4)
./tests/test_calculate_assignment.py            < 1, 2, 1> (2.4)
./tests/test_calculate_branch.py                < 1, 2, 1> (2.4)

Finalmente, puede pasar un argumento cores para decirle a la biblioteca cuántos núcleos de CPU usar. Por defecto, la biblioteca intentará usar todos los núcleos que están disponibles en su máquina.