pyoload

pyoload

¡Hy Pythonista! Estoy feliz de presentarte pyoload , como de mis palabras:

Un módulo de Python para verificación de tipo extendido y recursivo de los argumentos de funciones y atributos de clase durante el tiempo de ejecución

Aquí utilizamos algunas de las características hermosas y limpias que ofrece Python, incluidos los decoradores y descriptores para ayudarlo a escribir durante el tiempo de ejecución.

Aquí hay algunos ejemplos de uso simples para llenar esta página PYPI.

anotar

Esta función del decorador utiliza el poder de inspect.signature para verificar los argumentos transmitidos a la función utilizando sus anotaciones con soporte para valores predeterminados, aliaces genéricos y anotaciones agregando algunos tipos de anotación más para conveniencia, disminuya algún código.

 from pyoload import *

@ annotate
def foo (
    a : str ,     # this has an annotation
    b = 3 ,        # this uses a default value
    c : int = 0  # here both
) -> tuple [ str , int ]:  # The return type
    ...

 from pyoload import *

@ annotate
def foo (
    b = dict [ str | int , float ],     # here a GenericAlias
    c : Cast ( list [ int ]) = '12345'  # here a recursive cast
):  # No return type
    ...

multimetod

Esto utiliza los mismos principios que Annotate, pero permite el envío múltiple (¿también conocido como sobrecarga de tiempo de ejecución?) De funciones.

 from pyoload import *

@ multimethod
def foo ( a , b ):
    print ( "two arguments" )

@ multimethod
def foo ( a : Values (( 1 , 2 , 3 ))):
    print ( 'either 1, 2 or 3' )

@ foo . overload
def _ ( a : Any ):
    raise ValueError ()

anotaciones

Estos son lo que Pyoload agrega a las anotaciones estándar:

Nota

Las anotaciones adicionales aún no se pueden fusionar con los tipos estándar.

pyoload.Values

Una subclase tuple simple, úsalos como anotación y validará solo valores incluidos.

 @ annotate
def foo ( bar : Values ( range ( 5 ))):
    ...

pyoload.Cast

Esto realiza la fundición recursiva de los argumentos aprobados en el tipo especificado que admite alias genéricos dict como dict[str, int | str] e intenta fundir en el orden especificado cuando el tipo es una unión.

 @ annotate
def foo ( bar : Cast ( tuple [ int | str ])):
    print ( bar )

foo (( 3 , "3" ))  # (3, 3)
foo (( 3j , " " ))  # ('3j', ' ')

pyoload.Checks

Le permite usar métodos de verificación personalizados, por ejemplo

 from pyoload import *

test = lambda val : True  # put your check here

def foo ( a : Checks ( func = test ):
    ...

Si el nombre de la verificación se prefiere con un _ , se negará y se plantea una excepción si falla. Puede registrar sus propios cheques usando Check.register , como

 @ Check . register ( 'mycheck' )
def _ ( param , value ):
    print ( param , value )

Checks ( mycheck = 'param' )( 'val' )  # Will raise error on check failure

@ annotate
def foo ( a : Checks ( mycheck = 'param' )):
    ...

Los controles se pueden usar como anotaciones; llamado usando pyoload.Checks como Checks(foo=bar)(val) ; o invocado directamente usando pyoload.Checks como: Check.check(name, param, arg)

fila

Recibe como argumento un valor entero especificó la longitud esperada o una porción en la que se debe encontrar la longitud

GT, LT, EQ

Compara rallador que, menor y aqual desde el parámetro con el valor.

concurrido

Utiliza una función para la validación, la función podría devolver un booleano o aumentar un error. Podría pasarse directamente como argumentos posicionales a Pyoload. Comprobaciones como: Checks(func1, func2, foo=bar, foo2=bar2)

Atributos marcados y fundidos

CheckedAttr y CastedAttr , son descriptores simples que realizarán la asignación de casting o verificación de la asignación.

 from pyoload import *

class address :
    number = CastedAttr ( tuple [ int ])
    

Los valores se marcan o se dicen en la asignación

Nota

Los atributos no devolverán None si aún no se inicializan