Published 1.1.362

Bug Fixes:

• Fixed a bug that results in incorrect type narrowing when a match statement uses an empty (zero-element) sequence pattern and the subject expression type is a tuple that potentially (but does not always) have a zero length.
• Fixed a crashing bug that results from an internal assertion failure when a generic class that uses PEP 695 syntax is located within an unreachable code block.
• Fixed a bug that results in incorrect type narrowing in the negative (fall-through) case when a match statement includes a class pattern with a runtime-checkable protocol class.
• Fixed recent regression with the TypeIs type guard that resulted in incorrect type narrowing in the negative (else) case.
• Fixed a bug that results in incorrect type evaluation for a variable that uses a nonlocal or global binding within an inner scope. Such a variable should never honor the narrowed type from the outer scope.
• Fixed false positive when a TypeVar appears within a function type comment.
• Fixed incorrect type narrowing for a class pattern argument if the class is a generic whose type parameters have default values.
• Fixed recent regression that resulted in incorrect type narrowing when a *args: P.args parameter was used in the expression len(args) >= x.
• Fixed a bug that resulted in a false negative when a Literal with multiple arguments is used in a value expression. It should be treated as a UnionType special form in this case.

Enhancements:

• Addressed a performance issue when indexing into a value that has a type consisting of a union of many (dozens or hundreds) of tuple types.
• Updated typeshed stubs to the latest version.

Behavior Changes:

• Changed interpretation of function definitions with (*args: Any, **kwargs: Any) to be ... in compliance with latest typing spec.
• Added special-case handling for __init_subclass__ checks for classes that have ABCMeta as a metaclass. Previously, these were exempted from __init_subclass__ because ABCMeta has a custom __new__ method, but we know that this metaclass calls through to type.__new__ which calls __init_subclass__.

Published 1.1.361

Bug Fixes:

• Fixed a bug that results in a false negative when using bidirectional type inference to evaluate the type of a lambda expression if the expected type is a union of two or more callables.
• Fixed bug caused by incorrect synthesis of item and keys attributes for named tuple classes.
• Fixed bug that resulted in incorrect bidirectional type inference when calling a constructor for a generic class that defines no __new__ or __init__ method.
• Fixed bug that results in a false positive error when a yield statement is used within a lambda following a function.
• Fixed a bug that led to poor performance (effectively a hang) if an unannotated function is called through many (greater than 8) call expressions within a loop using different literal-value arguments each time.
• Fixed a bug that results in a false positive error when using __extra_items__ (PEP 728) with a TypedDict imported from typing_extensions.
• Fixed a bug that leads to an infinite loop when performing protocol matching under certain circumstances that involve recursive protocol definitions.
• Fixed a bug that results in a false positive error when Callable() is used as a class pattern and the subject type is Any or Unknown.
• Fixed a false negative that occurs when reassigning a Final variable within a class body.
• Changed the tokenizer so it is bug-for-bug compatible with the CPython tokenizer in versions 3.10 and newer in the case where a backslash (continuation character) is located by itself on a line.
• Fixed a bug that results in incorrect type evaluation when a global (module-scoped) variable is captured within an inner scope and the variable is not modified anywhere below the inner scope. It's possible in this case for the variable to be modified by code outside of the module.
• Fixed bug that resulted in incorrect evaluation of an identifier used in a method parameter type annotation if it shadows a forward reference in a class scope when the method is using PEP 695 type parameters.
• Fixed a bug that results in a false negative when an Unpack is used in a union. This isn't allowed.
• Fixed bug that produces incorrect output when converting to a textual representation the type type[Foo] where Foo is a type alias.

Behavior Changes:

• Changed logic that synthesizes the constructor methods for a NamedTuple subclass (using the class syntax) so the __new__ method contains parameters based on field names and the __init__ method contains a general *args: Any, **kwargs: Any parameter signature. Previously, this was swapped, but the new way is more faithful to the runtime.
• Changed TypeIs to use the same logic as isinstance type narrowing logic for consistency.

Published 1.1.360

Enhancements:

• Added support for @deprecation messages for decorators that wrap a function in a callable object. The deprecated message is now propagated through the ParamSpec and the __call__ method.
• Updated typeshed stubs to the latest version.

Behavior Changes:

• Moved check for invalid use of class-scoped TypeVar within a self annotation in __init__. It was previously reported under reportGeneralTypeIssues, but it's now moved to reportInvalidTypeVarUse. This was done to help typeshed maintainers migrate away from this pattern.
• Changed behavior to no longer exempt unguarded access to not-required TypedDict member within a try or with block. Previously, such errors were exempt, but this is inconsistent with other type checks in pyright which eschew the practice of using exception handling for normal code flow.

Bug Fixes:

• Fixed recent regression that affected unannotated __call__ methods in a metaclass. This change aligns pyright's behavior to the typing spec.
• Fixed recent regression that incorrectly narrowed the type of kwargs when used in a type guard of the form if "a" in kwargs.
• Fixed bug in protocol matching that results in a false positive when the subject object is a dataclass that contains a callable. It should be considered an instance member in this case, so it should not be bound to the class.
• Fixed a bug that results in a false positive error when bidirectional type inference is used for a dictionary comprehension when the expected type is a union.
• Redesigned the handling of PEP 695-style type parameter scoping to better match the CPython runtime implementation. This fixes multiple bugs with type parameter symbol resolution. For example, if a type parameter is quoted as a forward reference.
• Fixed bug that leads to false negative when binding an object to an overloaded method where all of the overloads have incompatible self parameter types.
• Fixed bug that leads to incorrect metatype for a class object that is created by calling the metaclass with a two-argument form.

Published 1.1.359

Enhancements:

• Expanded support for len(x) == L type guard pattern (where x is a tuple) to support <, <=, > and >= comparisons as well.
• Improved some diagnostic messages, moving away from the term "member" to prefer "attribute". Switched from "cannot assign to type" to "incompatible with type" for consistency and clarity.
• Extended type narrowing logic for in and not in operators that target TypedDicts to also support constrained TypeVars that use TypedDicts as value constraints.
• Added a check for the case where a frozen dataclass overrides a field from its parent class but doesn't provide a default value (where its parent does). This can result in a type violation if the parent's default value is not compatible with the child's (covariant) field type.

Behavior Changes:

• Changed behavior when evaluating the upper bound expression, value constraints expression, or default expression for a PEP-695 type parameter. At runtime, these are always evaluated in a deferred manner even if they are not quoted. Pyright now follows the runtime behavior.
• Modified handling of annotated self parameter in __init__ method when evaluating constructor call so pyright conforms to the latest typing spec.
• Added missing check for the errant use of class-scoped type variables in a type annotation for the "self" parameter within an "init" method. The typing spec now clarifies that this is illegal and should generate an error.
• Updated logic for converting a class constructor to a callable to conform to the newly-updated typing spec.
• Changed the behavior when invoking constructor for type[T] where T is a TypeVar with no explicit upper bound (and therefore has an implicit upper bound of object). According to the newly-clarified typing spec, this should enforce the constructor signature of object.
• Modified behavior in constructor call code that previously applied some (now non-compliant) heuristics to reconcile a metaclass __call__ method with a __new__ method. The new behavior is now compliant with the typing spec.
• Changed behavior of conversion from class constructor to callable to conform with the typing spec in the case where the __new__ method of the class returns a value that indicates the __init__ method should be ignored.
• Changed behavior of conversion from class constructor to callable to conform to honor the annotated type of self in the __init__ method.
• Changed behavior of conversion from class constructor to callable to conform to honor return type of the __new__ method.

Bug Fixes:

• Fixed a bug that leads to inconsistent behaviors when an assignment leads to a type violation. When assigning to a local variable, the target expression is not "narrowed" to include the assigned type in this case. The new behavior applies this same behavior when assigning to instance or class variables.
• Fixed recent regression that results in a false positive error when applying a @property decorator to a method that has already had a decorator applied to it.
• Fixed bug that results in a spurious reportAbstractUsage error when an abstract class is captured through a type[T].
• Fixed bug that results in incorrect type evaluation when solving a ParamSpec type when there are multiple constraints provided.
• Fixed a bug that results in incorrect type evaluation when assigning a function with a NoReturn return type to a Callable[..., T].
• Fixed a bug that leads to a false negative when an unparenthesized assignment expression is used in a dictionary key within a dictionary expression or comprehension.
• Fixed bug that results in false positive error under certain circumstances that involve unions of TypeVars in an invariant context.

Published 1.1.358

Bug Fixes:

• (from Pylance): Fixed a bug that caused a crash under certain circumstances when an import cannot be resolved.
• Fixed non-compliance issue with TypeIs, which is documented to have an invariant type parameter.
• Fixed a bug that results in incorrect type evaluation when a sequence pattern in a match statement includes a * element and the subject includes a tuple with an element with indeterminate length.
• Fixed bug that results in an intermittent false positive "circular dependency" error for fields within a dataclass.
• Fixed a bug that results in a false positive error under certain circumstances when a TypeVar or TypeVarTuple is being solved with literal values in both an invariant and non-invariant context.
• Fixed bug that results in incorrect type evaluation in cases where a generic function returns a callable, and the function is called with a higher-order generic function as an argument.
• Fixed a bug that results in a false negative when a generic function returns a Callable type that is specialized to include a live (in-scope) type variable.
• Fixed bug that results in inconsistent type narrowing on assignment based on whether the assignment occurs within the same statement that includes the (declared) type annotation for the variable and whether the type annotation is provided as a type comment.

Enhancements:

• Added optimization for TypedDict type assignments. Under certain circumstances (e.g. when comparing large unions of TypedDict types), this can save significant time.
• Modified the handling of enum class attributes so those with private (mangled) names are exempted from being considered enum members. This reflects the runtime behavior.
• Added support for narrowing of subject subexpression within a match statement for references to the subexpression after the completion of the match statement.
• Updated typeshed stubs to the latest version.
• Improved error handling for quoted annotations. Bytes, raw strings, and f-strings are not allowed according to the typing spec.
• Added an error message for a Literal type annotation that includes a string with a named unicode escape sequence. These are not supported.

Published 1.1.357

Bug Fixes:

• Fixed bug that results in a false positive error when explicitly calling __new__ on a dataclass, namedtuple, or TypedDict. These classes all require synthesized __new__ methods.
• Fixed bug that results in false negative when a __new__ or __init__ method cannot be bound without a type violation.
• Fixed a bug that results in incorrect type narrowing of enums that derive from enum.Flag.
• Fixed a type hole when a dictionary expression includes a dictionary expansion operator that acts on a non-closed TypedDict.
• Fixed bug that results in a type not being narrowed when using the K in TD type guard pattern (where TD is a TypedDict and K is a literal key). Narrowing was skipped if the RHS operand was not a simple identifier.
• Fixed inconsistent handling of literal values in a list comprehension.
• Fixed a bug that results in a false positive error when an unpacked TypeVarTuple is used in a function defined with PEP-695 syntax.
• (From Pylance) Improved heap usage tracking within language server to reduce the likelihood of crashes related to heap exhaustion.
• Fixed a bug that results in incorrect inferred parameter types for an unannotated method in a subclass when the parent class method contains function-scoped TypeVars.

Enhancements:

• Added support for negative (fall-through) type narrowing for subject subexpressions in match statement when subject consists of a tuple expression and patterns exhaustively match the tuple.
• Enhanced dictionary type evaluation to support dictionary items that overwrite previous dictionary items. Only the last value type is now considered, so if previous values (which are overwritten) would otherwise violate typing rules, this no longer generates a type error.
• Enhanced discriminated class support to include not only literal field values but also None.
• Improved diagnostic message for access to unknown member in the case where the user probably meant to access an item in a TypedDict but used a member access expression rather than an index expression.
• Improved return result for synthesized get method for closed TypedDict classes (as defined in PEP 728).
• Refactored tokenizer and parser output to help reduce the amount of memory needed.

Behavior Changes:

• Changed the handling of Final variables (that are not explicitly marked ClassVar) within dataclass class bodies. This is consistent with the runtime and this proposed change to the typing spec.

Published 1.1.356

Bug Fixes:

• Fixed bug that results in a false positive error when a class-scoped TypeVar with a default that references another class-scoped TypeVar is used in a method signature in that class.
• Fixed bug that resulted in a false positive error if a PEP-695 type statement uses a type parameter and encloses the RHS in quotes.
• Fixed bug that results in incorrect type narrowing in the negative (fall-through) case when a runtime-checkable protocol class is used as a class pattern with arguments within a match statement.
• Fixed a bug that results in a false positive when a class-scoped TypeVar used within a method has a default that refers to another class-scoped TypeVar.
• Fixed a bug that results in a false positive reportImplicitOverride diagnostic if the class derives from an Unknown or Any class.

Behavior Changes:

• Tweaked bidirectional type inference behaviors for lists to improve certain inference cases.
• Changed the logic for metaclass instance variable lookups to ignore the lookup if the metaclass MRO contains an unknown class.

Enhancements:

• Update Unicode range tables to match Unicode 15.1.
• Added check for the use of a non-runtime-checkable protocol class in a class pattern. This generates an exception at runtime.
• Updated typeshed stubs to the latest version.

Published 1.1.355

Bug Fixes:

• Fixed a bug that results in incorrect type evaluation if a list expression includes a generator expression.
• Fixed bug that results in a false negative when a TypeAliasType object is used in a class pattern.
• Fixed bug that results in false positive when implicitly specializing a class parameterized by a TypeVarTuple when there is no default.
• Fixed bug that results in false positive when a list or set expression is evaluated using bidirectional type inference when the expected type is MutableSet or MutableSequence.
• Fixed bug that results in a false negative when overriding a method that has keyword parameters with a method that has a *args parameter.
• Fixed a bug that results in a false positive error in certain circumstances involving a TypeVarTuple used within an overload.
• Fixed bug that results in a false positive error when a base class defines a writable property and a subclass writes to the property.
• Fixed bug that results in a false positive "overload implementation does not match overloads" diagnostic when positional-only and keyword-only parameters are involved.
• Fixed a bug that results in a false positive in a complex situation that involves generic protocols, properties, and mix-in classes.
• Fixed bug that results in false positive error when a __new__ method in a metaclass uses PEP 692 (unpacked TypeDict) to annotate its **kwargs parameter.

Enhancements:

• Updated typeshed stubs to the latest. This version of typeshed replaces the older-style positional-only parameters with PEP 570 syntax.
• Improved validation for except and except* statements to catch some previously-undetected invalid cases.
• Expanded handling of python versions to handle more than just major/minor version numbers. Pyright now handles micro, releaseLevel, and serial numbers as well.

Published 1.1.354

Bug Fixes:

• Fixed a bug that resulted in an incorrect type evaluation when an augmented assignment is used within an inner-scoped function to add a constant to a variable. Literal math should not be used in this case.
• Fixed two bugs that resulted in false negatives when redefining a constant variable with a non-variable symbol and when redefining a Final variable with a non-variable symbol.
• Fixed bug that results in false positive when a generic class or type alias uses a TypeVarTuple followed by one or more ParamSpecs that have default values.
• Fixed bug that resulted in false negative when narrowing a constrained or bound TypeVar with a complex() or float() class pattern.
• Fixed bug that results in a false positive under certain circumstances when a constrained TypeVar is used as the default for another constrained TypeVar.
• Fixed a bug that results in a false positive under certain circumstances when defining a type alias using the old typing.TypeAlias annotation.
• Fixed a bug that results in a false negative when a class explicitly inherits from a protocol that defines an instance variable but the child re-declares as a ClassVar without an explicit type.
• Fixed a bug that made locale overrides through environment variables no longer work on node 21.

Enhancements:

• Enhanced handling of type function when it is passed a class. Pyright previously evaluated this as Any, but now it returns the class' metaclass.
• Added check for generic classes and type aliases that include a TypeVarTuple followed by a TypeVar that has a default value. This is illegal according to PEP 696.
• Changed the behavior when accessing a class attribute from a generic class that is not specialized. The class is now automatically specialized in the case using default type parameter values (from PEP 696) or Unknown. This change is required for conformance with PEP 696.
• (From pylance) Added some optimizations to the tokenizer to reduce memory usage.
• Added new reportUnhashable diagnostic rule.

Published 1.1.353

Breaking Changes:

• The CLI and language server versions of pyright now require a minimum node version of 14. Previously node 12 and 13 were supported.

Enhancements:

• Enabled PEP 705 and PEP 696 functionality without the use of enableExperimentalFeatures now that these PEPs are officially accepted.
• Improved support for instance variables whose type is declared in a metaclass. Pyright now honors this type and enforces type consistency in derived classes.

Bug Fixes:

• Fixed a bug that results in a false negative when a dundered method overrides a base class method of the same name and uses different parameter names along with different types.
• Fixed a bug that leads to a false positive error when a match statement is used in a loop and the subject expression is potentially narrowed as a result of the match statement.
• Added check for inappropriate use of Annotated passed as second argument to NewType call.
• Fixed a bug that results in a false positive error when expanding the type arguments to a TypeVarTuple under certain circumstances.
• Fixed a bug that results in incorrect type evaluation when an index expression is assigned a value within a doubly-nested loop under certain circumstances.
• Fixed a regression that caused the signature help provider to not display the __new__ method of a constructor if it is overloaded.
• Fixed hard-coded type information for module attribute __package__. It should be str | None rather than str.
• Fixed a bug in the isinstance type guard logic. It was not properly handling tuples that included unions.
• Fixed bug in signature help provider so str method docstrings are showed when called on LiteralString.
• Fixed a bug that results in incorrect type narrowing behavior for member access expressions under certain circumstances.
• Fixed bug that resulted in a false negative when a possibly-unbound variable is captured by an inner scope under certain circumstances.