aldanor
commented
6 years ago Ok, as a continuation of previous discussion in #215... :)
@glyph I was trying to find https://github.com/aldanor/typo today but instead I ran across https://github.com/RussBaz/enforce which looks like it may be a fairly full-featured version of the same thing.
@chadrik There is also https://github.com/Stewori/pytypes May the best project win.
Just to clarify, the sole reason I've started one of my own was that all existing solutions (those including enforce and pytypes) were (a) slow and (b) wrong -- although both are very good attempts and good inspiration. That being said, my version is not fully type-correct either when it comes to sum types (see examples below), but 'less wrong' if I may; on the bright side, it's fast. I haven't spent any time on finishing it due to lack of motivation and time lately, but it could be done, maybe with some help. If anyone knows any other comparable or relevant projects - shout away, I'd personally be very interested.
TL;DR: it's hard to write a runtime type checker that's both fast and correct, especially if it aims to handle both typevars and sum types; although not impossible (I'm not sure one already exists at this moment however). Details below.
# pip install git+https://github.com/RussBaz/enforce.git
import enforce
# pip install git+https://github.com/aldanor/typo.git (3.5 only; needs a few fixes)
import typo
# pip install git+https://github.com/Stewori/pytypes.git
import pytypes
# pip install # git+https://github.com/agronholm/typeguard.git
import typeguardSimple example:
def simple(x: int, y: str): pass
simple_pytypes = pytypes.typechecked(simple)
simple_enforce = enforce.runtime_validation(simple)
simple_typeguard = typeguard.typechecked(simple)
simple_typo = typo.type_check(simple)
args = 1, 'foo'
%timeit -r7 -n1000 simple_pytypes(*args)
%timeit -r7 -n1000 simple_enforce(*args)
%timeit -r7 -n1000 simple_typeguard(*args)
%timeit -r7 -n1000 simple_typo(*args)314 µs ± 23 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
155 µs ± 2.14 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
51.6 µs ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
497 ns ± 3.13 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)All three work correctly; typeguard is 100x slower, enforce 300x, pytypes 600x.
Slightly more involved:
from typing import List, Union, Dict, Tuple
def nested(x: Dict[Tuple[int, bytes], List[Union[str, float]]]) -> int: return 1
nested_pytypes = pytypes.typechecked(nested)
nested_enforce = enforce.runtime_validation(nested)
nested_typeguard = typeguard.typechecked(nested)
nested_typo = typo.type_check(nested)
x = {(1, b'3'): ['a', 1., 'b', 3.], (3, b'1'): [], (4, b'5'): ['c', 3.14]}
# %timeit -r7 -n1000 nested_pytypes(x) # FAILS
%timeit -r7 -n1000 nested_enforce(x)
%timeit -r7 -n1000 nested_typeguard(x)
%timeit -r7 -n1000 nested_typo(x)2.08 ms ± 23.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
176 µs ± 1.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4.57 µs ± 169 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)Three out of four work -- pytypes fails, typeguard is 40x slower, enforce 450x.
Simple generic example (with a catch):
from typing import TypeVar
A, B = TypeVar('A'), TypeVar('B')
def generic1(x: List[Union[A, int]], y: A): pass
generic1_pytypes = pytypes.typechecked(generic1)
generic1_enforce = enforce.runtime_validation(generic1)
generic1_typeguard = typeguard.typechecked(generic1)
generic1_typo = typo.type_check(generic1)
args = [1], 'b' # valid signature (A=str)
# %timeit -r7 -n1000 generic1_pytypes(*args) # FAILS
# %timeit -r7 -n1000 generic1_enforce(*args) # FAILS
# %timeit -r7 -n1000 generic1_typeguard(*args) # FAILS
%timeit -r7 -n1000 generic1_typo(*args)4.19 µs ± 206 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)Three out of four fail.
And finally...
def generic2(x: Union[A, B], y: A, z: B): pass
generic2_pytypes = pytypes.typechecked(generic2)
generic2_enforce = enforce.runtime_validation(generic2)
generic2_typeguard = typeguard.typechecked(generic2)
generic2_typo = typo.type_check(generic2)
args = 'a', 3, 'b' # valid signature (A=int, B=str)
# %timeit -r7 -n1000 generic2_pytypes(*args) # FAILS
# %timeit -r7 -n1000 generic2_enforce(*args) # FAILS
# %timeit -r7 -n1000 generic2_typeguard(*args) # FAILS
# %timeit -r7 -n1000 generic2_typo(*args) # FAILSAll four fail, amen.
agronholm
Stewori
Tinche
euresti
hynek
pwwang
ghost
This has been proposed and discussed in https://github.com/python-attrs/attrs/issues/215, as a possible use case for the newly added
typeargument toattr.ib()#239quoting @hynek https://github.com/python-attrs/attrs/issues/215#issuecomment-347529479