typeddjango/awesome-python-typing

Collection of awesome Python types, stubs, plugins, and tools to work with them.

Awesome Python Typing

Collection of awesome Python types, stubs, plugins, and tools to work with them.

Contents

• Static type checkers
• Dynamic type checkers
• Stub packages
• Additional types
• Backports and improvements
• Tools
• Integrations
• Articles
• Communities
• Related

Full list of typed projects on PyPi is here.

Static type checkers

• basedmypy - Based static typing with baseline functionality.
• basedpyright - Pyright fork with improvements to VSCode support and various other fixes.
• mypy - Optional static typing (PEP 484).
• pyanalyze - Extensible static analyzer and type checker.
• pycharm - IDE for Professional Developers.
• pylyzer - A fast static code analyzer & language server for Python, written in Rust.
• pyre - Performant type-checker.
• pyright - Fast type checker meant for large Python source bases. It can run in a “watch” mode and performs fast incremental updates when files are modified.
• pytype - Tool to check and infer types - without requiring type annotations.

Dynamic type checkers

• beartype - Unbearably fast O(1) runtime type-checking in pure Python.
• pydantic - Data parsing using Python type hinting. Supports dataclasses.
• pytypes - Provides a rich set of utilities for runtime typechecking.
• strongtyping - Decorator which checks whether the function is called with the correct type of parameters.
• typedpy - Type-safe, strict Python. Works well with standard Python.
• typeguard - Another one runtime type checker.
• typical - Data parsing and automatic type-coercion using type hinting. Supports dataclasses, standard classes, function signatures, and more.
• trycast - Parse JSON-like values whose shape is defined by typed dictionaries (TypedDicts) and other standard Python type hints.

Stub packages

• asgiref - ASGI specification, provides asgiref.typing module with type annotations for ASGI servers.
• boto3-stubs - Stubs for boto3.
• botostubs - Gives you code assistance for any boto3 API in any IDE.
• celery-types - Type stubs for Celery and its related packages django-celery-results, ampq, kombu, billiard, vine and ephem.
• django-stubs - Stubs for Django.
• djangorestframework-stubs - Stubs for DRF.
• grpc-stubs - Stubs for grpc.
• lxml-stubs - Stubs for lxml.
• PyQt5-stubs - Stubs for PyQt5.
• python-phonenumbers-stubs - Stubs for phonenumbers.
• pythonista-stubs - Stubs for Pythonista.
• sqlalchemy-stubs - Stubs for SQLAlchemy.
• sqlalchemy2-stubs - Official stubs and mypy plugin for SQLAlchemy.
• torchtyping - Enhanced type annotations for pytorch.
• types-aiobotocore - Stubs for aiobotocore.
• typeshed - Collection of library stubs, with static types.

Additional types

• meiga - Simple, typed and monad-based Result type.
• option - Rust like Option and Result types.
• optype - Opinionated collections.abc and operators alternative: Flexible single-method protocols and typed operators with predictable names.
• phantom-types - Phantom types.
• returns - Make your functions return something meaningful, typed, and safe.
• safetywrap - Fully typesafe, Rust-like Result and Option types.
• typet - Length-bounded types, dynamic object validation.
• useful-types - Collection of useful protocols and type aliases.

Backports and improvements

• future-typing - Backport for type hinting generics in standard collections and union types as X | Y.
• typing-extensions - Backported and experimental type hints.
• typing-utils - Backport 3.8+ runtime typing utils(for eg: get_origin) & add issubtype & more.

Tools

Linters

• flake8-annotations-complexity - Plugin for flake8 to validate annotations complexity.
• flake8-annotations - Plugin for flake8 to check for presence of type annotations in function definitions.
• flake8-pyi - Plugin for Flake8 that provides specializations for type hinting stub files.
• flake8-type-checking - Plugin to help you guard any type-annotation-only import correctly.
• flake8-typing-imports - Plugin which checks that typing imports are properly guarded.
• flake8-typing-only-imports - flake8 plugin that helps identify which imports to put into type-checking blocks, and how to adjust your type annotations once imports are moved.
• flake8-type-ignore - flake8 plugin to disallow type: ignore comments in your typed Python code.
• wemake-python-styleguide - The strictest and most opinionated Python linter ever.
• Ruff - Extremely fast linter which supports lint rules from many other lint tools, such as flake8.

Testing

• mypy-test - Test mypy plugins, stubs, custom types.
• pytest-mypy-plugins - Pytest plugin for testing mypy types, stubs, and plugins.
• pytest-mypy-testing - Pytest plugin to test mypy static type analysis.
• pytest-mypy - Mypy static type checker plugin for Pytest.

Working with types

• com2ann - Tool for translation of type comments to type annotations.
• merge-pyi - Part of pytype toolchain, applies stub files onto source code.
• mypy-baseline - Integrate mypy with existing codebase. A CLI tool that filters out existing type errors and reports only new ones.
• mypy-protobuf - Tool to generate mypy stubs from protobufs.
• mypy-silent - Silence mypy by adding or removing code comments.
• mypyc - Compiles mypy-annotated, statically typed Python modules into CPython C extensions.
• retype - Another tool to apply stubs to code.
• typeforce - CLI tool that enriches your Python environment with type annotations, empowering mypy.
• typesplainer - A Python type explainer.
• typing-inspect - The typing_inspect module defines experimental API for runtime inspection of types defined in the typing module.
• typing-json - Lib for working with typed objects and JSON.

Helper tools to add annotations to existing code

• autotyping - Automatically add simple return type annotations for functions (bool, None, Optional).
• infer-types - CLI tool to automatically infer and add type annotations into Python code.
• jsonschema-gentypes - Generate Python types based on TypedDict from a JSON Schema.
• monkeytype - Collects runtime types of function arguments and return values, and can automatically generate stub files or even add draft type annotations directly to your code based on the types collected at runtime.
• no_implicit_optional - A codemod to make your implicit optional type hints PEP 484 compliant.
• pyannotate - Insert annotations into your source code based on call arguments and return types observed at runtime.
• PyTypes - Infer Types by Python Tracing.
• pyre infer - Pyre has a powerful feature for migrating codebases to a typed format. The infer command-line option ingests a file or directory, makes educated guesses about the types used, and applies the annotations to the files.
• pytest-annotate - Pyannotate plugin for pytest.
• pytest-monkeytype - MonkeyType plugin for pytest.
• pytype annotate-ast - A work-in-progress tool to annotate the nodes of an AST with their Python types.
• type4py - Deep Similarity Learning-Based Type Inference.
• typilus - A deep learning algorithm for predicting types in Python. Also available as a GitHub action
• auto-optional - Makes typed arguments Optional when the default argument is None.

Mypy plugins

• kubernetes-typed - Plugin for kubernetes CRD type checking.
• loguru-mypy - Plugin for loguru support.
• mypy-zope - Plugin for zope.interface support.
• mypy/plugins - Plugins already integrated into mypy.
• numpy - Plugin for NumPy support.
• pynamodb-mypy - Plugin for PynamoDB support.

Integrations

• emacs-flycheck-mypy - Mypy integration for Emacs.
• mypy-playground - Online playground for mypy.
• mypy-pycharm-plugin - Mypy integration for PyCharm.
• pylance - PyRight integration for VSCode.
• vim-mypy - Mypy integration for Vim.
• nbQA - Run type checkers (e.g. Mypy) on Jupyter Notebooks.

Articles

PEPs

• PEP-3107 - Function Annotations.
• PEP-482 - Literature Overview for Type Hints.
• PEP-483 - The Theory of Type Hints.
• PEP-484 - Type Hints.
• PEP-526 - Syntax for Variable Annotations.
• PEP-544 - Protocols: Structural subtyping (static duck typing).
• PEP-557 - Data Classes.
• PEP-560 - Core support for typing module and generic types.
• PEP-561 - Distributing and Packaging Type Information.
• PEP-563 - Postponed Evaluation of Annotations.
• PEP-585 - Type Hinting Generics In Standard Collections.
• PEP-586 - Literal Types.
• PEP-589 - TypedDict: Type Hints for Dictionaries with a Fixed Set of Keys.
• PEP-591 - Adding a final qualifier to typing.
• PEP-593 - Flexible function and variable annotations.
• PEP-604 - Complementary syntax for Union[].
• PEP-612 - Parameter Specification Variables.
• PEP-613 - Explicit Type Aliases.

Third-party articles

• 1-minute guide to real constants in Python - Full tutorial about Final constants and inheritance.
• Simple dependent types in Python - Full tutorial about Literal types.
• Testing mypy stubs, plugins, and types - Full tutorial about testing mypy types.
• Our journey to type checking 4 million lines of Python - Dropbox has been one of the first companies to adopt Python static type checking at this scale.
• PyTest MonkeyType Introduction - Type Annotate an existing Python Django Codebase with MonkeyType.
• The state of type hints in Python - As of May 2018.
• Type hints cheat sheet - Cheat sheet on writing type annotations by MyPy team.
• Typechecking Django and DRF - Full tutorial about type-checking django.
• Type Check Your Django Application - An article based on two recent talks on adding type checks to Django.
• typing - Official Python documentation for typing module.
• Python-typing-koans - A set of examples to learn optional static typing in Python.
• Python Type Checking (Guide) - In this guide, you will get a look into Python type checking.
• Adding type hints to urllib3 - Tests are not enough: Case study adding type hints to urllib3.
• Adam Johnsons Blog - Adam Johnson blogs about typing practices.
• ParamSpec Guide - Newly released feature in PEP612 allows you do a lot of advanced typing things with functions and their signatures.
• Static Typing Python Decorators - Accurately static typing decorators in Python is an icky business. The wrapper function obfuscates type information required to statically determine the types of the parameters and the return values of the wrapped function.

Communities

• python/typing - Official typing gitter chat.
• TypedDjango - Official organisation gitter chat.
• PythonRu#typing - Russian slack chat (invites are here) about types.

Related

• awesome-python - Curated list of awesome Python frameworks, libraries, software and resources.
• python-typecheckers - List of Python type checkers: static and runtime.

awesome-python-typing's Issues

[Request] Please list "beartype" in the "Dynamic type checkers" section

Thanks for all the awesome typing lists, @sobolevn, @orsinium, and other fearless contributors. If someone could find a spare moment to add a terse link to beartype, a recently released constant-time (i.e., O(1) with negligible constants at call time regardless of container size) runtime type checker compliant with Python 3.6—3.9 and PEPs 483, 484, 540, 560, 563, 593 and soon to be compliant with PEP 585 that I personally maintain, that would be... like, super awesome: e.g.,

• beartype - Constant-time runtime type checker.

...or something. I leave everything to your skilled and talented hands.

Thanks again. This has been an extreme year for humanity, so I humbly appreciate everyone's continued focus on this small (but crucial) slice of the Python pie. You're all awesome!

Curses helper i made, maybe fits.

I got started on so.e curses helper stuff, including a (to be expanded) types module. You can find it on my github. Currently it has a window type.

Add `strongtyping` to the list of runtime typecheckers

https://strongtyping.readthedocs.io

Suggest adding mypy-protobuf

Project link: https://github.com/dropbox/mypy-protobuf

Should be categorized to "Tools" IMO

Some offerings

Caveat: I do not have experience with the tools yet, but they aren't the first thing I googled, either.

Tools (not sure what subcategory):
https://pypi.org/project/typing-json/
https://github.com/contains-io/typingplus/
https://github.com/contains-io/typet

Articles (new subcategory: Python doc):
https://docs.python.org/3/library/typing.html

Articles (Third party):
https://www.bernat.tech/the-state-of-type-hints-in-python/

Disable Projects, Wiki, Security tabs for repo

Create CONTRIBUTING.md

https://github.com/sindresorhus/awesome/blob/master/pull_request_template.md

Add section for additional types

Some tools allow to have empowered type annotations, extending mypy capabilities. Let's talk if we want a new section for them or "mypy plugins" fits well enough.

• https://github.com/dry-python/returns
• https://github.com/antonagestam/phantom-types
• https://github.com/mplanchard/safetywrap
• https://github.com/contains-io/typet
• https://github.com/alice-biometrics/meiga
• https://github.com/MaT1g3R/option

Add data-science-types

data-science-types - provides stubs for numpy, pandas, and matplotlib.

Pravda

Brand new, to keep an eye on:
https://github.com/wemake-services/pravda
Python type-checker written in Rust

Add Python-typing-koans when matured

https://github.com/kracekumar/python-typing-koans

Python-typing-koans
A set of examples to learn optional static typing in Python.

One of the best of ways to learn python-typing is to annotate the code. In this repo, koans directory contains a set of files which will teach you python type-hints by fixing errors. The files carry a suffix from 100 in the increasing order. By solving errors in the each file in the increasing suffix order, you will gain knowledge about Python hints. It starts with simple variable annotation and covers topics function annotation, generics, protocols, classes.

How to learn?
The existing files has no annotations or wrong annotation, as a learner, you run one file and fix each errors till there are no type-errors. In the next section, you will learn, how to list all koans and how to run the modified koan file.

The issue is just meant to be a reminder/Note to self, to create a PR once the repo has matured enough to be included

add pyannotatate

Add this list to https://github.com/sindresorhus/awesome and similar

There are multiple lists like this one!

We also need to mature for at least 30 days. So, October will be the date.

numpy-stubs is archived

https://github.com/numpy/numpy-stubs

These stubs have been merged into NumPy, and all further development will happen in the NumPy main repo. We welcome your contributions there!

Run awesome-lint on this list

https://github.com/sindresorhus/awesome/blob/master/pull_request_template.md

Suggest adding to Articles

Below is a personal document I wrote before, might be useful for people who are new to python typing, feel free to take some into the Articles part.

---

Python Type Hints

Basic Guides

• PEP 483 -- The Theory of Type Hints: https://www.python.org/dev/peps/pep-0483/
• PEP 484 -- Type Hints: https://www.python.org/dev/peps/pep-0484/
• PEP 3107 -- Function Annotations: https://www.python.org/dev/peps/pep-3107/
• PEP 526 -- Syntax for Variable Annotations: https://www.python.org/dev/peps/pep-0526/
• mypy
  • Python 3: https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html
  • Python 2: https://mypy.readthedocs.io/en/latest/cheat_sheet.html
• PyCharm: https://www.jetbrains.com/help/pycharm/type-hinting-in-product.html

Advanced Guides

PEP 563 -- Postponed Evaluation of Annotations

https://www.python.org/dev/peps/pep-0563/

This PEP describes the support of referencing a type that is yet to defined in the annotation, and how to enabling it by calling from __future__ import annotations in Python after 3.7

In Python before 3.7 (<= 3.6), same thing can be achieved by adding single quote around the type, this is called Forward references in PEP 484.

Literal

• mypy Literal: https://mypy.readthedocs.io/en/latest/literal_types.html
• PEP 586 -- Literal Types: https://www.python.org/dev/peps/pep-0586/

Protocol

• mypy Protocol: https://mypy.readthedocs.io/en/latest/protocols.html
• PEP 544 -- Protocols: Structural subtyping (static duck typing): https://www.python.org/dev/peps/pep-0544/

Generic

• mypy Generics: https://mypy.readthedocs.io/en/latest/generics.html
• PEP 483 Defining and using generic types: https://www.python.org/dev/peps/pep-0483/#defining-and-using-generic-types
• PEP 484 User-defined generic types: https://www.python.org/dev/peps/pep-0484/#user-defined-generic-types

data-science-types has stopped development

https://github.com/predictive-analytics-lab/data-science-types/

data-science-types has archived the github repository and stopped development due to types added into the upstream packages.

Libraries and frameworks leveraging Type annotations

Should there be a section about tools, libraries, frameworks that leverage type annotations, like FastAPI, Pydantic, Typer, ... ?

Background: I just stumbled over https://github.com/cal-pratt/flexdi and was wondering how to promote something like this. https://github.com/pschanely/CrossHair is another example falling into this category (if we want to make one)

Add python-typecheckers to the list

https://github.com/ethanhs/python-typecheckers

We can also add some important libs from there to our own list.

Ruff: A new, fast and correct Python checker/linter

Please have a look at ruff.

An extremely fast Python linter, written in Rust.
https://github.com/charliermarsh/ruff

Notes on ruff
https://whynothugo.nl/journal/2023/01/20/notes-on-ruff/

A pre-commit hook for Ruff.
https://github.com/charliermarsh/ruff-pre-commit

I have no association with ruff or its developer(s).