pyoload

Pyoload

Hy Pythonista! Ich freue mich, Ihnen pyoload zu präsentieren, wie aus meinen Worten:

Ein Python -Modul für erweiterte und rekursive Typen und Casting von Funktionsargumenten und Klassenattributen während der Laufzeit

Hier verwenden wir einige der schönen und sauberen Funktionen von Python, einschließlich Dekoratoren und Deskriptoren, um Ihnen dabei zu helfen, die Überprüfung während der Laufzeit zu tippen

Hier sind einige einfache Verwendungsbeispiele, um diese PYPI -Seite zu füllen.

kommentieren

Diese Dekorationsfunktion verwendet die Kraft der inspect.signature , um die an die Funktion übergebenen Argumente mithilfe ihrer Annotationen mit Unterstützung für Standardwerte, generische Aliase und Anmerkungen hinzu, was weitere Annotationstypen zur Bequemlichkeit hinzufügen, um einen Code zu senken.

 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

Dies verwendet dieselben Prinzipien wie Annotate, ermöglicht jedoch mehrere Versand (auch bekannt als Überladung von Laufzeit?) Von Funktionen.

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

Anmerkungen

Dies sind das, was Pyoload zu den Standardanmerkungen ergänzt:

Notiz

Die hinzugefügten Anmerkungen können mit den Standardtypen immer noch nicht fusionierbar sind.

pyoload.Values

Eine einfache tuple -Unterklasse, verwenden Sie sie als Annotation und validieren nur Werte.

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

pyoload.Cast

Dies führt ein rekursives Gießen der übergebenen Argumente in den angegebenen Typen aus, den es unterstützt, dict generische Aliase als dict[str, int | str] und versucht, in der angegebenen Reihenfolge zu sein, wenn der Typ eine Gewerkschaft ist.

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

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

pyoload.Checks

Ermöglicht, dass Sie benutzerdefinierte Checker -Methoden verwenden, z. B.

 from pyoload import *

test = lambda val : True  # put your check here

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

Wenn der Prüfname mit einem _ vorbereitet wird, wird er negiert und eine Ausnahme wird erhöht, wenn er fehlschlägt. Sie können Ihre eigenen Schecks über Check.register registrieren wie

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

Überprüfungen können als Anmerkungen verwendet werden. mit pyoload.Checks als Checks(foo=bar)(val) aufgerufen; oder direkt mit pyoload.Checks als: Check.check(name, param, arg) aufgerufen werden.

Len

Empfängt als Argument einen ganzzahligen Wert

GT, LT, Gl

Vergleicht Reisen als weniger als und aqual mit dem Parameter zum Wert.

Func

Verwendet eine Funktion zur Validierung, die Funktion könnte einen Booleschen zurückgeben oder einen Fehler erhöhen. Es könnte direkt als Positionsargumente an pyoload übergeben werden Checks(func1, func2, foo=bar, foo2=bar2)

Überprüfte und gegossene Attribute

CheckedAttr und CastedAttr sind einfache Deskriptoren, die die Casting oder Überprüfungen für die Zuordnung durchführen.

 from pyoload import *

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

Die Werte werden auf die Zuordnung überprüft oder abgegossen

Notiz

Die Attribute geben None zurück, wenn sie noch initialisiert werden