awesome-repositories.com
博客
awesome-repositories.com

通过 AI 驱动的搜索，发现最优秀的开源仓库。

探索精选搜索开源替代品自托管软件博客网站地图
项目关于排名机制媒体报道MCP 服务器
法律隐私政策服务条款
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
facebook avatar

facebook/pyrefly

0
View on GitHub↗
5,390 星标·278 分支·Rust·mit·6 次浏览pyrefly.org↗

Pyrefly

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 existing errors. Preset-based strictness tiers—safe, strict, and custom—control the level of checking. The checker natively understands Django ORM models, class-based views, and Pydantic models, inferring types without plugins. It integrates with CI pipelines through pre-commit hooks and inline error annotations on pull requests.

Pyrefly’s incremental architecture re-checks only modified files, providing sub-second feedback. Import resolution prefers stub files over source code and bundles type stubs for popular libraries. The language server offers autocomplete, hover information, inlay hints, signature help, code actions, and navigation features such as go-to-definition, find all references, call and type hierarchies, and workspace symbol search. Diagnostics appear in notebooks and with semantic token highlighting.

Configuration is handled through project files with options for import resolution, typeshed paths, and types of errors to report. The checker measures type coverage and can report per-module statistics.

Features

  • Python Type Checkers - Catches type mismatches and invalid operations in Python code before runtime with configurable strictness and fast incremental analysis.
  • Static Shape Validators - Validates tensor shape consistency at compile time using symbolic arithmetic and shape rules for operations.
  • Tensor Shape Inferences - Infers tensor shapes automatically from operations and reports mismatches without manual annotations.
  • Symbolic Tensor Shape Analyzers - Infers tensor shapes using symbolic dimension variables and arithmetic to verify shape consistency at compile time.

AI 搜索

探索更多 awesome 仓库

用简单的语言描述您的需求 —— AI 将根据相关性为您从数千个精选开源项目中进行排序。

Start searching with AI
  • Static Shape Validators - Verifies tensor shape consistency in deep learning models at compile time using symbolic dimension variables.
  • Framework Support - Provides native static analysis type inference for Django, Pydantic, and similar frameworks without plugins.
  • Django ORM Model - Infers types for Django ORM model fields and relationships without plugins.
  • Argument Type Mismatch Detectors - Provides static detection of argument type mismatches before code execution.
  • Language Server Protocols - Connects a Python type checker to any LSP-compatible editor to deliver diagnostics, autocomplete, and navigation.
  • Language Servers - Delivers diagnostics, completions, and navigation via the Language Server Protocol for any compatible editor.
  • Stub-First Import Resolvers - Prefers .pyi stub files and -stubs packages over source code for static type information.
  • Generic Types - Supports generic types and type-safe polymorphism through parameterized type variables.
  • Type-Based Overloading - Supports defining multiple type signatures for functions to alter return types based on input types.
  • Structural Type Equivalences - Validates types based on their structure and attributes, supporting duck typing without explicit inheritance.
  • Static Type Inference - Infers variable types from code without requiring explicit annotations.
  • Optional Value Types - Represents values that may be one of several types or None for flexible type definitions.
  • Gradual Typing Adoption - Migrates existing Python projects to type safety by generating configuration from other checkers and suppressing current errors.
  • Static Type Checking - Reports type mismatches and invalid attribute accesses statically without executing code.
  • Pydantic Model Validations - Executes static analysis that mirrors Pydantic runtime validation rules to catch data model errors in the editor.
  • Dimension String Annotations - Accepts dimension string annotations for linking tensor dimensions to type-level symbols during static analysis.
  • Dimension Type Extractors - Extracts runtime dimension types from tensors while preserving symbolic links for subsequent shape verification.
  • Model Shape Annotation Porting - Automates porting of tensor shape annotations for compile-time shape safety.
  • Symbolic Dimension Arithmetics - Performs symbolic arithmetic on dimension types for expressing tensor shape transformations at compile time.
  • Tensor Shape Annotations - Links runtime tensor dimensions to type-level symbols for shape consistency verification.
  • LSP Server Configurations - Configures the LSP server to work in various editors via Language Server Protocol.
  • LSP-Integrated Environments - Connects to editors using the Language Server Protocol to deliver diagnostics and completions.
  • Configurable Strictness Levels - Provides safe, strict, and custom preset strictness tiers to control type error reporting.
  • Incremental Type Checkers - Performs incremental type checking with sub-second feedback for fast editing cycles.
  • Symbol Search Interfaces - Searches globally for functions, classes, and variables across the project.
  • Automated Type Checking Pipelines - Runs type checks automatically on every push or pull request and blocks commits that introduce type errors.
  • Call Hierarchies - Shows incoming and outgoing function calls in a structured hierarchy.
  • Cancellation-Aware Incremental Checkers - Implements incremental file re-checking and cancels stale analyses, providing instant feedback on edits.
  • Inline Diagnostic Displays - Shows type errors and warnings from the static checker in the diagnostics pane as you type.
  • Code Navigators - Provides code navigation and hints across editors via a standardized protocol.
  • Declaration Navigations - Provides go-to-declaration navigation as a built-in language server feature.
  • Type Definition Navigations - Jumps to the underlying type definition of an expression.
  • Type Hint Integrations - Delivers type information to the editor for inline error markers and enhanced autocompletion.
  • Inlay Hint Renderers - Displays inferred types and parameter names as virtual text directly in the editor.
  • Django Type Inference Engines - Infers types for Django model fields, relationships, and generic views without requiring plugins or manual annotations.
  • Automatic Suppression Additions - Scans projects and automatically suppresses pre-existing type errors for gradual adoption.
  • Temporary Suppression Mechanisms - Adds temporary ignore comments to suppress new errors after dependency upgrades.
  • Automatic Signature Help Displays - Shows live function signatures with parameter hints as the user types a function call.
  • Implementation Navigations - Ships go-to-implementations navigation for exploring method reimplementations.
  • Module Import Resolvers - Searches user paths, typeshed, and site-packages in fixed priority order for accurate module resolution.
  • Bundled Type Stubs - Ships pre-bundled type stubs for popular libraries to enable static checking without manual installation.
  • Type Stub Generators - Generates type stub files from Python source code for static type checking without runtime execution.
  • Strictness Preset Configurators - Offers safe, strict, and custom presets to control type checking severity and rules.
  • Symbol Navigation - Jumps from a symbol usage to its original definition, preferring source files.
  • Hover Information Displays - Displays type information and documentation inline when hovering over symbols in the editor.
  • Type Checker Configuration Migrations - Automatically migrates configuration from other type checkers for gradual adoption.
  • Continuous Integration Checks - Runs type checking automatically on every push or pull request inside continuous integration pipelines.
  • Symbolic Dimension Declarations - Declares tensor shapes with symbolic dimension variables and arithmetic for static shape consistency.
  • Import Path Resolution - Resolves absolute imports by searching user paths, typeshed, site-packages, and fallback locations.
  • Python Import Resolution Configurators - Configures import resolution by setting search paths, site-packages, typeshed, and autodetecting Python interpreter.
  • Relative Import Resolvers - Resolves relative import statements by ascending from the importing file's directory.
  • Static Analysis Rule Configurators - Adjusts strictness via presets, controls unannotated definitions, return type inference, callable subtyping, and specialized lints.
  • Codebase Symbol References - Lists every usage of a symbol across the entire codebase.
  • Diagnostic Filtering and Suppression - Filters diagnostics by severity, suppresses known errors with a baseline, and formats output for CI or display.
  • Issue Baselining - Creates a baseline of known errors to report only new regressions, enabling gradual adoption.
  • Type Hierarchies - Shows all subclasses and superclasses of a selected class in a hierarchy view.
  • Type Coverage Analysis - Measures type annotation coverage and can fail on low coverage or export statistics.
  • Rule Suppression Comments - Suppresses type errors via inline or file-level comments.
  • Code Autocomplete Engines - Provides context-aware autocomplete suggestions for symbols and imports as the user types in the editor.
  • Semantic Highlighters - Applies rich syntax highlighting based on token type and origin from semantic analysis.
  • Class-Based View Type Checking - Infers types for Django class-based views and mixins without plugins.
  • Code Analysis - Listed in the “Code Analysis” section of the Awesome Python awesome list.
  • 开发者工具 - Fast typechecker and IDE support for Python.
  • Rust Projects - Listed in the “Rust Projects” section of the Awesome For Beginners awesome list.
  • Static Type Checkers - Fast type checking and language server implementation.
  • Type Checking - Fast type checker and language server.

    • Star 历史

    facebook/pyrefly 的 Star 历史图表facebook/pyrefly 的 Star 历史图表

    Pyrefly 的开源替代方案

    相似的开源项目，按与 Pyrefly 的功能重合度排序。
    • google/pytypegoogle 的头像

      google/pytype

      5,037在 GitHub 上查看↗

      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

      Pythonlinterpythonstatic-analysis
      在 GitHub 上查看↗5,037
    • microsoft/vscode-cpptoolsmicrosoft 的头像

      microsoft/vscode-cpptools

      6,047在 GitHub 上查看↗

      The C/C++ extension for Visual Studio Code provides language support for C and C++ programming, including IntelliSense-powered code editing, navigation, and debugging capabilities. It enables syntax highlighting, code completion, hover information, and error checking for C and C++ source files, along with features like semantic colorization, symbol search, and call hierarchy exploration. The extension offers comprehensive debugging support for C/C++ programs, including launching debug sessions with breakpoints, stepping through code, and inspecting variables. It supports debugging multi-threa

      TypeScriptmicrosofttypescriptvscode-extension
      在 GitHub 上查看↗6,047
    • c3lang/c3cc3lang 的头像

      c3lang/c3c

      5,147在 GitHub 上查看↗

      c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

      C3c3compilerlanguage
      在 GitHub 上查看↗5,147
    • elm/compilerelm 的头像

      elm/compiler

      7,794在 GitHub 上查看↗

      This project is a functional programming compiler and JavaScript transpiler that transforms a statically typed language into optimized JavaScript for web browsers. It serves as a frontend architecture framework, providing a static type system and a package manager that enforces semantic versioning. The compiler uses a type-checking engine with automatic type inference to prevent runtime errors and guide code refactoring. It implements a structural pattern for managing application state and rendering user interfaces through a virtual DOM, utilizing immutable data and purity-based state transit

      Haskellcompilerelm
      在 GitHub 上查看↗7,794
    查看 Pyrefly 的所有 30 个替代方案→

    常见问题解答

    facebook/pyrefly 是做什么的？

    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.

    facebook/pyrefly 的主要功能有哪些？

    facebook/pyrefly 的主要功能包括：Python Type Checkers, Static Shape Validators, Tensor Shape Inferences, Symbolic Tensor Shape Analyzers, Framework Support, Django ORM Model, Argument Type Mismatch Detectors, Language Server Protocols。

    facebook/pyrefly 有哪些开源替代品？

    facebook/pyrefly 的开源替代品包括： google/pytype — Pytype is a static code analysis tool and type inference engine for Python. It functions as a static type analyzer… microsoft/vscode-cpptools — The C/C++ extension for Visual Studio Code provides language support for C and C++ programming, including… rust-lang/rust-by-example — This project is an interactive programming education resource and tutorial designed for learning the Rust programming… elm/compiler — This project is a functional programming compiler and JavaScript transpiler that transforms a statically typed… c3lang/c3c — c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static… zigtools/zls — ZLS is a language server for the Zig language that implements the Language Server Protocol to provide IDE-like…