Mypy

mypy is a static type checker for Python that analyzes source code to detect type errors and inconsistencies without executing the program. It functions as a static analysis tool and type inference engine, providing a gradual typing system that allows type hints to be added to a codebase incrementally while maintaining compatibility with dynamic typing.

The project distinguishes itself through a combination of performance and precision features. It utilizes a daemon-based incremental checking system and multi-process parallel analysis to manage large codebases, supported by binary cache persistence to accelerate subsequent builds. It also includes the ability to transform Python modules into C extensions using type hints to increase execution performance.

The analyzer covers broad capability areas including flow-sensitive type narrowing, match statement exhaustiveness verification, and the validation of variadic generics and typed dictionaries. It manages external dependencies through type stub validation and the analysis of untyped modules. The toolset also includes automated integration for continuous integration pipelines and recursive configuration file discovery.

Features

Gradual Typing Systems - Provides a gradual typing system allowing type hints to be added incrementally while maintaining dynamic typing compatibility.

Automatic Type Deduction - Automatically determines variable and expression types to reduce the need for manual annotations.

External Library Definitions - Uses separate definition files to provide type information for libraries that do not have internal annotations.

Type Narrowing - Refines variable types based on conditional checks and type guards as the analyzer traverses the control flow.

Abstract Syntax Tree Parsers - Parses Python source code into an abstract syntax tree to extract semantic information for static analysis.

Python Type Checkers - A static analysis tool specifically designed to detect type errors and inconsistencies in Python source code.

Gradual Typing Adoption - Allows adding type hints to an existing Python codebase incrementally while maintaining compatibility with dynamic typing.

Type Inference Engines - Automatically determines variable types to reduce the requirement for manual annotations in Python.

Gradual Typing Frameworks - Provides a framework for adding type hints to Python codebases incrementally while maintaining compatibility with dynamic typing.

Static Code Analysis Tools - Scans source code to identify bugs and type inconsistencies before runtime execution.

Type Accuracy Validation - Validates that external type definition files accurately reflect the actual runtime behavior of the code.

Parallel Type Validation - Distributes code analysis across multiple worker processes to reduce the total time required for type validation.

TypedDict Validation - Checks for read-only items and flexible update operations within specialized dictionary type definitions.

Static Analysis Caches - Stores previously analyzed module states in binary format to avoid re-processing unchanged source files.

Analysis Result Caches - Stores intermediate analysis results in binary formats to avoid redundant processing of unchanged files.

Scale-Aware Analysis - Utilizes incremental checks and parallel analysis to manage type safety in extensive Python projects.

Incremental Type Validation - Provides background daemon support for fast, real-time type updates in large codebases.

Incremental Analysis Daemons - Maintains a long-running background process that keeps the codebase in memory for faster single-file updates.

Override Enforcement - Requires specific decorators on methods that override base class members to prevent accidental modifications.

Variadic Template Arguments - Verifies functions and classes that utilize a variable number of generic arguments.

Type-Based Contract Validation - Verifies that function signatures and complex generic types are used correctly across different modules.

Deprecation Management - Automatically issues warnings when the codebase utilizes features marked as outdated or deprecated.

Exhaustiveness Checkers - Generates errors when a match statement fails to cover all possible values of the subject type.

Parallel Processing Utilities - Distributes the type-checking workload across multiple worker processes to utilize multi-core CPUs.

Untyped Module Analysis - Performs forced analysis of imports from external libraries lacking formal type definitions.

Variable Usage Analysis - Identifies variables used before definition based on program control flow to prevent runtime errors.

Annotation Tools - Compiles statically typed Python modules into C extensions.

Code Analysis - Listed in the “Code Analysis” section of the Awesome Python awesome list.

Code Quality Tools - Optional static type checker for Python.

Developer Tools - Static type checker.

Python Projects - Listed in the “Python Projects” section of the Awesome For Beginners awesome list.

Static Type Checkers - The standard static type checker implementing PEP 484.

Type Checkers - Standard static type checker for Python codebases.

Type Checking - Compile-time variable type checking.

pythonmypy

Features

Star history