Herramientas de análisis estático que identifican errores de tipo y aplican sugerencias de tipos dentro del código fuente de Python.
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 persi
mypy is the standard static type checker for Python, offering type inference, gradual typing, stub support, editor integration, and file-based configuration, which directly matches the need for static type analysis without execution.
Pytype is a static code analysis tool and type inference engine for Python. It functions as a static type analyzer that detects type mismatches and verifies type annotations without requiring full manual hinting, while also serving as a type stub generator for producing standalone definition files. The project distinguishes itself by automatically determining variable and function types through an analysis of code patterns and assignments. This inference engine allows for structural code verification and the generation of type stubs that describe the interfaces of modules and functions. The
Pytype is a full-featured static type checker for Python that combines automatic type inference, gradual typing, stub file generation, configurable rules, and integration-friendly error reporting, covering every aspect the visitor is looking for.
Pyright is a static type checker for Python designed to validate type hints and identify potential errors within large codebases. It functions as a command-line utility that integrates into local development environments and continuous integration pipelines to ensure code quality and consistency. The tool distinguishes itself through a high-performance analysis engine that utilizes incremental dependency graph analysis and persistent state caching to re-evaluate only the affected portions of a project. By implementing the Language Server Protocol, it provides real-time feedback, including err
Pyright is a dedicated static type checker for Python that uses fast incremental analysis, supports gradual typing and stub files, integrates with editors via the Language Server Protocol, and provides configurable error reporting—covering every feature this search asks for.
This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments. The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checkin
This is a high-performance static type checker for Python that also provides a language server for editor integration, supports gradual typing and file-based configuration, and delivers detailed error reports — matching all the key features you need for static analysis without running code.
Pyre is a high-performance static type checker and analysis tool for Python. It identifies type errors and ensures type safety without executing the program, utilizing a static type inference engine to maintain consistency across functions. The project is distinguished by an incremental type analysis engine that operates as a background daemon. This system monitors filesystem changes to re-validate only modified parts of a project, reducing the time required for repeated analysis. It also includes a static analysis security tool that uses taint analysis to track untrusted data flows and ident
Pyre is a dedicated Python static type checker with an incremental type inference engine, stub file support, and editor integration, covering all the required features for catching type errors without running the code.
Pyrefly is a static type checker for Python that operates as a language server, delivering real-time diagnostics, completions, and navigation in any editor supporting the Language Server Protocol. It also performs static tensor shape analysis, using symbolic dimension variables and arithmetic to verify shape consistency in deep learning models without runtime execution. Beyond core type checking, Pyrefly supports gradual adoption workflows: it can generate a baseline of known errors so only new issues are reported, migrate configuration from other type checkers, and automatically suppress exi
Pyrefly is a static type checker for Python that runs as a language server, providing real-time type diagnostics, inference, gradual typing, and editor integration via LSP—directly matching your need to catch type errors without execution.