pyoload

pyoload

Hy Pythonista! Je suis heureux de vous présenter pyoload , comme de mes mots:

Un module Python pour la vérification étendue et récursive de type et coulant des arguments de fonction et des attributs de classe pendant l'exécution

Ici, nous utilisons certaines des fonctionnalités belles et propres offertes par Python, y compris les décorateurs et les descripteurs pour vous aider à vérifier pendant l'exécution

Voici quelques exemples d'utilisation simples pour remplir cette page PYPI.

annoter

Cette fonction de décorateur utilise la puissance de inspect.signature

 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
    ...

multiméthode

Cela utilise les mêmes principes qu'annotate mais permet de répartir plusieurs (aka surcharge d'exécution?) Des fonctions.

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

annotations

Ce sont ce que Pyoload ajoute aux annotations standard:

Note

Les annotations supplémentaires ne sont toujours pas fusionnables avec les types standard.

pyoload.Values

Une simple sous-classe tuple , utilisez-les comme annotation et elle validera uniquement les valeurs.

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

pyoload.Cast

Cela effectue une coulée récursive des arguments passés dans le type spécifié qu'il prend en charge les alias génériques dict comme dict[str, int | str] et essai dans l'ordre spécifié lorsque le type est une union.

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

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

pyoload.Checks

Vous permet d'utiliser des méthodes de vérificateur personnalisé, par exemple

 from pyoload import *

test = lambda val : True  # put your check here

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

Si le nom de chèque est apparenté avec un _ , il sera nié et une exception est élevée en cas d'échec. Vous pouvez enregistrer vos propres chèques en utilisant Check.register , comme

 @ 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' )):
    ...

Les chèques peuvent être utilisés comme annotations; Appelé en utilisant pyoload.Checks en tant que Checks(foo=bar)(val) ; ou invoqué directement à l'aide pyoload.Checks comme: Check.check(name, param, arg)

Len

Reçoit comme argument, une valeur entière spécifiait la longueur attendue ou une tranche dans laquelle la longueur doit être trouvée

GT, LT, EQ

Compare la râpe que, moins que et aqual du paramètre à la valeur.

func

Utilise une fonction pour la validation, la fonction pourrait renvoyer un booléen ou augmenter une erreur. Il pourrait être transmis directement comme arguments de position à Pyoload.Checks comme: Checks(func1, func2, foo=bar, foo2=bar2)

Attributs vérifiés et coulés

CheckedAttr et CastedAttr , sont des descripteurs simples qui effectueront le casting ou les chèques en affectation.

 from pyoload import *

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

Les valeurs sont vérifiées ou coulées en affectation

Note

Les attributs ne rendront None sinon encore initialisé