pyoload

pyoload

Hy Pythonista! Fico feliz em apresentar a você pyoload , como pelas minhas palavras:

Um módulo Python para verificação e elenco de tipos estendidos e recursivos de argumentos de função e atributos de classe durante o tempo de execução

Aqui usamos alguns dos recursos bonitos e limpos oferecidos pela Python, incluindo decoradores e descritores para ajudá -lo a digitar a verificação durante o tempo de execução

Aqui estão alguns exemplos de uso simples para preencher esta página do Pypi.

anotar

Esta função do decorador usa o poder do inspect.signature para verificar os argumentos passados ​​para a função usando suas anotações com suporte para valores padrão, Aliase genérico e anotações adicionando mais alguns tipos de anotação por conveniência, reduzem algum 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
    ...

Multimethod

Isso usa os mesmos princípios que o Anotate, mas permite a despacho múltiplo (aka Runtime Sobrecarregar?) De funções.

 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 ()

anotações

É isso que o pyoload adiciona às anotações padrão:

Observação

As anotações adicionadas ainda não são incorporadas com os tipos padrão.

pyoload.Values

Uma subclasse simples tuple , use -os como anotação e validará apenas valores incluídos.

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

pyoload.Cast

Isso executa o elenco recursivo dos argumentos aprovados no tipo especificado que suporta aliases genéricos dict como dict[str, int | str] e tenta lançados na ordem especificada quando o tipo é um sindicato.

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

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

pyoload.Checks

Permite que você use métodos de verificador personalizado, por exemplo

 from pyoload import *

test = lambda val : True  # put your check here

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

Se o nome de verificação estiver preso com um _ , ele será negado e uma exceção será aumentada se falhar. Você pode registrar seus próprios 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' )):
    ...

Os cheques podem ser usados ​​como anotações; chamado usando pyoload.Checks como Checks(foo=bar)(val) ; ou chamado diretamente usando pyoload.Checks como: Check.check(name, param, arg)

Len

Recebe como argumento um valor inteiro especificado o comprimento esperado ou uma fatia em que o comprimento deve ser encontrado

GT, LT, Eq

Compara o ralador do que, menos e aqual ao parâmetro ao valor.

functão

Usa uma função para validação, a função pode retornar um booleano ou levantar um erro. Pode ser passado diretamente como argumentos posicionais para pyoload.chaks como: Checks(func1, func2, foo=bar, foo2=bar2)

Atributos verificados e fundidos

CheckedAttr e CastedAttr , são descritores simples que executarão a fundição ou cheques na atribuição.

 from pyoload import *

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

Os valores são verificados ou fundidos na tarefa

Observação

Os atributos retornarão None , se ainda não inicializado