ensure

unittest with https://github.com/kislyuk/ensure

Fine, but it's just an import away: https://github.com/kislyuk/ensure (written by HN user ak217)

Thanks for the link. I developed the annotation+decorator-based type checker in https://github.com/kislyuk/ensure before I saw typecheck-decorator (which looks like it has some cool features). One thing I'm proud of with ensure's @ensure_annotations decorator is that we actually went through a few rounds of optimization and are fairly confident in the decorator's runtime performance. Optional type checking as a first-class citizen is a great tool to have, and it's good to see the syntax standardized. But as alluded to in the Reddit thread, there are serious issues with this PEP. The use of comments and the lack of runtime type checking from the start not only limits the potential of this particular PEP, but undermines future efforts to bring that functionality in. IMO it would have been better to put in the work and properly integrate typ

My contribution is https://github.com/kislyuk/ensure It's fast and doesn't monkey-patch things.

Related: https://github.com/kislyuk/ensure A (relatively) high performance runtime annotation type checker. from ensure import ensure_annotations @ensure_annotations def f(x: int, y: float) -> float: return x+y

I wrote a decorator-driven library to do optional type checking at runtime with no need for a special interpreter :) https://github.com/kislyuk/ensure (Having optional static type checks in the core interpreter would be nice, though Alex Gaynor's concerns linked in another comment are very valid.)

Very nice and fun presentation. Another feature not in this talk is function annotations (http://legacy.python.org/dev/peps/pep-3107/) and things they enable like optional runtime type checking (https://github.com/kislyuk/ensure#enforcing-function-annotat...). Also, as a library developer, I wanted to highlight some facts from experience with Python 2/3 development: - Travis CI is an invaluable resource for running your test suite on a number of Python versions at once. It has deep integration with GitHub, and together they make the development flow a lot less cumbersome. - Writing to a subset of Python that is compatible with both 2.7 and 3.3+ is not terribly hard. Lots of resources exist out there, including Armin's porting guide, six, python-future, and eight (https://github.com/kislyuk/eight­). - Contrary to some opinions out there, P

There are a lot of ideas out there on how to do optional runtime type checking in a Pythonic way. My contribution is ensure (https://github.com/kislyuk/ensure), for example check out the ensure_annotations decorator (https://ensure.readthedocs.org/en/latest/#ensure.ensure_anno...).

For Python 3, I've added optional type checking based on function annotations and decorators to the Ensure library: https://github.com/kislyuk/ensure#enforcing-function-annotat.... @ensure_annotations def f(x: int, y: float) -> float: return x+y f(1, 2.3) >>> 3.3 f(1, 2) >>> ensure.EnsureError: Argument y to <function f at 0x109b7c710> does not match annotation type <class 'float'> I think it works better than other approaches mentioned here because it (1) doesn't repeat the contents of the function signature, (2) doesn't install any magic system-wide hooks (and the attendant performance issues), and (3) is completely optional.

I've added a type checking decorator for function annotations to my assertions helper library, https://github.com/kislyuk/ensure: from ensure import ensure_annotations @ensure_annotations def f(x: int, y: float) -> float: return x+y f(1, 2.3) >>> 3.3 f(1, 2) >>> ensure.EnsureError: Argument y to <function f at 0x109b7c710> does not match annotation type <class 'float'> It's useful sometimes.

I wrote a library so you don't have to use this: https://github.com/kislyuk/ensure (Though I know how frustrating exception juggling can get... especially when they get pickled and re-raised)

I was frustrated with the limited utility and expressiveness of Python assertions, so I wrote a library for expressive assertions: https://github.com/kislyuk/ensure It's inspired by ensure.js, and defines a large (and growing) number of helpers to make assertions concise, easy to read, customizable, and more usable than the assert statement. (Feedback welcome!)