Skip to main content
100%

Contracts in Python

✓ Published0🌍 Public
Aadewes
Last edited Jul 12, 2017
Created on Jul 12, 2017

This example demonstrates runtime type checking for Python function arguments and return values using function annotations and custom validator classes. The code defines a `Validated` metaclass and validator classes like `TypeChecked`, `Range`, and `Positive`, which are combined through the `checked` decorator to enforce constraints such as type and value ranges on parameters like `x`, `y`, and `z`. It uses the `inspect` module to parse function signatures and annotations, and the `functools` module for wrapping. The sample function `f` shows valid and invalid calls, raising `TypeError` for type mismatches and `ValueError` for out-of-range values.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 87f69df227eafef3f4fc3774184404e2

This example shows a collection of Python metaclasses and decorators that manipulate class creation, initialization, and function signatures. The code defines metaclasses like `FixSigMeta`, which adjusts `__signature__` based on overridden `__init__` methods, and `PrePostInitMeta`, which calls optional `__pre_init__` and `__post_init__` hooks. Decorators such as `delegates` and `use_kwargs_dict` rewrite `**kwargs` parameters by borrowing signatures from other functions or classes. The implementation relies on the `inspect` module to read and replace `Parameter` objects, with no external data source or rendering involved.

深深度碎片
49% match
Loading thumbnail…

Gist 45e3155420d18420a34a

This example demonstrates multiple approaches to implementing multimethod dispatch in Python, showing how the same `foo` function can behave differently based on argument types. It first uses the `multimethod` decorator with explicit type annotations for `int`, `float`, and `str` inputs, then shows an alternative `ifmatches` decorator style from a blog post, with a reference to a third `patmatch` recipe. The code snippets contrast syntaxes and highlight the evolution of pattern-matching techniques in Python.

Aandybak
48% match
Loading thumbnail…

Gist 7699534

This example demonstrates a jQuery plugin for form validation, where input fields are checked against rules like presence, email format, and numeric ranges. Valid and invalid states trigger CSS classes (`pass`/`fail`) through event handlers. The implementation defines custom jQuery functions (`jQuery.fn.valid`, `jQuery.fn.validate`) that listen for events such as `focusout`, `keydown`, and `submit`, using the `jQuery(@).data()` API to track validity. The usage sample binds validators to elements with the class `form-control.required`, applying the declared callbacks for live feedback.

DDylanFM
46% match
Loading thumbnail…

Gist b33154065c8c297e8bb1ee38a500a7f6

This example shows how to convert Python type annotations into a structured prompt that guides users through solving problems with the fastcore library’s py2pyi module. It uses plain text instructions and analogies to explain the module’s role in generating type stubs. The visualization relies on a text-based conversational interface, not graphical rendering, to break down tasks into beginner-friendly steps.

深深度碎片
45% match
Loading thumbnail…

A gist illustrating testing in Python using unittest

This example demonstrates how to structure and execute a Python test suite using the built-in `unittest` framework, alongside `doctest` for embedded documentation checks. It shows the definition of a `factorial` function and a `TestFactorial` class that validates expected outputs, error handling, and edge cases. The code dynamically generates test methods via `setattr` and uses `subTest` for granular failure reporting. It also illustrates skipping tests with `@unittest.skip`, suppressing console logging via `logging.NullHandler`, and controlling output with `unittest.main(buffer=True)`. The visible data source is the hardcoded test case list and doctest examples within the function docstring.

IIanHopkinson
44% match
Loading thumbnail…

Transforming Code into Beautiful, Idiomatic Python: notes from Raymond Hettinger's talk at pycon US 2013. The code examples and direct quotes are all from Raymond's talk. I've reproduced them here for my own edification and the hopes that others will find them as handy as I have!

This example presents a collection of code snippets from Raymond Hettinger’s PyCon 2013 talk, demonstrating how to refactor common Python patterns into more idiomatic and efficient forms. The notes show before-and-after comparisons, such as replacing `range` with `xrange`, using `enumerate` for indexed loops, and applying `iter` with a sentinel value. It covers looping over collections, dictionaries, and multiple sequences, highlighting APIs like `zip`, `izip`, `sorted`, and `iteritems`. The rendering is plain text within a markdown file, with no visual data or canvas involved.

Aabehmiel
43% match
Loading thumbnail…

A small script that warns about functions that are not called from within the code (fork from https://gist.github.com/Herst/287aa233c0acba6ed2bc2d093dec786d ported to Python 2)

This example demonstrates a Python script that identifies functions defined in source code but never called elsewhere in the same set of files. It shows how static analysis can flag potentially dead code for cleanup. The implementation uses Python's `ast` module and a custom `NodeVisitor` subclass to traverse abstract syntax trees, collecting both function definitions and references across multiple modules. A separate, simpler version relies on regular expressions via `re.findall` to match definitions and calls. Both approaches compare the set of defined names against referenced names, excluding patterns like `visit_*` or names starting with `test_`, and print the file and line number of each unused function.

HHerst
42% match
Loading thumbnail…

Gist fd0201fe95dfb4390a53

This visualization shows the parent-event relationships in a hierarchical data model, where each event must resolve to exactly one of four possible parent types: booking, stock change, repair, or missing. It demonstrates validation logic that raises exceptions when zero or multiple parents are found, ensuring data integrity in the event structure. The code uses Python’s `raise Exception` for error handling and list comprehensions to filter `None` values from the candidate parent list. The rendering approach is not visible in this snippet, which focuses solely on the data validation logic rather than visual output.

Aandybak
42% match