Published 1.1.390

Bug Fixes:

• Fixed recent regression that results in incorrect narrowed type when using the x in y pattern where y is a container type whose element type is Unknown or Any.
• Fixed bug that causes a false positive overlapping overload error when the overload accepts a Callable[..., T] form.
• Fixed a bug that results in a hang under certain circumstances when using a recursive type alias.
• Fixed a bug that leads to a false positive when a function is decorated and has no explicit return type annotation and the body references the decorated function in a loop.
• Fixed a bug that leads to incorrect type evaluation when __getitem__ is set to a callable object.
• Fixed bug that results in confusing error message when there is a partially-unknown metaclass type detected by the --verifytypes command.

Enhancements:

• Updated typeshed stubs to the latest version.
• Added check for \u and \N escapes within bytes literals, which are illegal.
• Added support for a "bare" Final annotation in a dataclass entry that has a default value assigned to it.
• Improved dataclass converters to support generic types.
• Added check for importing a Final variable from another module and then attempting to overwrite it.
• Added check for an attempt to assign to a module-local variable if it is shadowing a Final variable declared by the builtins module or some other chained file.
• Added support for evaluating the slice class type arguments for slice expressions.
• Added check for invalid use of ClassVar qualifier within a NamedTuple or TypedDict attribute annotation.

Behavior Changes:

• Changed inference logic for exception groups to more closely match the runtime. If a non-base exception is targeted, the inferred type is now ExceptionGroup rather than BaseExceptionGroup.

Published 1.1.389

Bug Fixes:

• Fixed bug that results in a false negative if a | union operator creates a union of generic types. These types should be specialized with default type arguments.
• Fixed bug that results in false negative when raising a value of type None.
• Fixed bug that results in an incorrect type evaluation when a match statement uses a pattern with a target expression that overwrites the subject expression.
• Fixed bug that results in a missing reportUnknownArgumentType error if the argument is an expression involving an __init__ parameter in an unannotated (pseudo-generic) class.
• Fixed bugs that resulted in false positive errors when using an expression of the form type(A) as a base class or a metaclass in a class definition.
• Fixed bug that leads to false positive when a method is overridden by a polymorphic method.
• Fixed bug that affects pyproject.toml files with an emoji character by switching to a different toml parser.
• Fixed a bug that results in a false negative when a class is used in a type annotation for a method parameter and both the class and the method are generic and use PEP 695 syntax.
• Fixed a bug that results in a false positive "--verifytypes" error when using an explicit TypeAliasType call to create a public symbol in a "py.typed" library.
• Fixed bug that results in the incorrect detection of an asymmetric descriptor if the descriptor class is generic.

Enhancements:

• [From Pylance]: Improved signature help to skip keyword-only params with invalid names.
• Added checks for except* clause to report invalid usage that is flagged as a syntax error at runtime.
• Added check for the illegal use of an await keyword in a lambda.
• Added missing checks for illegal use of await and async within list, set and dictionary comprehensions within a non-async function.
• Improved a confusing error message that results when a class is assigned to an incompatible class.
• Added narrowing support for a TypedDict value, which can be assumed never to be falsy if it has at least one required entry.
• Improved the "x is y" and "type(x) is y" type guards to better handle the case where x is a TypeVar.
• Updated typeshed stubs to the latest version.

Published 1.1.388

Bug Fixes:

• Fixed a bug that results in a false positive when a class is defined within a generic function and uses type parameters from that function.
• Fixed a bug that results in unexpected constraint solver results in certain cases involving arguments with lambda expressions.
• Fixed bug that results in false positive under certain circumstances involving classes parameterized with a contravariant type variable.
• Fixed bug that results in incorrect evaluation of class variables assigned in an __init_subclass__ or __class_getitem__ method. These methods are implicitly class methods even though they are not decorated with @classmethod.
• Removed recent check for illegal identifiers used in alias for dataclass_transform field. This isn't an illegal condition, so the resulting error was a false positive. Instead, changed completion provider to not suggest the illegal identifier as a valid keyword argument.

Enhancements:

• Enhanced the special-case logic for functools.partial so it handles the case where the function has a **kwargs parameter typed with an unpacked TypedDict.
• Improved the synthesized type of the keys, values and items methods on a closed TypedDict to provide a more precise (narrower) type for the key values.
• Improved the handling of a TypeVar whose definition involves a circular definition.
• Added check for __slots__ initialization when the __slots__ list is empty and the class is marked @final.

Published 1.1.387

Bug Fixes:

• Fixed bug that leads to a false negative when passing multiple *args or **kwargs arguments to a callable parameterized by a ParamSpec.
• Fixed issue that results in a false positive "type could not be determined because it refers to itself" error caused by a false dependency due to narrowing logic. This may also improve type analysis performance in some code.
• Switched to a different toml parser to avoid incompatibility with the latest toml standard.
• Changed the evaluated type of an in or not in operator to be bool if the LHS doesn't support containment. Previously, the expression evaluated to Never.
• Fixed a bug that results in a false positive when a class parameterized by a TypeVarTuple is used in conjunction with a Self type.
• Fixed bug that results in incorrect type evaluation when performing protocol matching that involves an attribute with a callable type parameterized by a ParamSpec.
• Added protection for an internal call stack overflow when inferring return types in deep call hierarchies within untyped code.
• Fixed a false positive "incompatible method override" error in a case that involves both class-scoped and method-scoped type variables.
• Fix recent regression that broke hover text on .get() of TypedDict instance.
• Fixed a bug that causes a false positive error when a class uses type(Protocol) as a base class.

Enhancements:

• Enhanced type narrowing logic for "x == " type guard pattern to handle the case where x is a type variable with a literal upper bound or value constraints that are literals.
• Improved detection of asymmetric descriptors to handle the case where the __set__ and __get__ methods are overloaded.
• Added experimental support for draft PEP 764: Inlined typed dictionaries.
• Changed check in the pyright VS Code extension for the presence of Pylance. If Pylance is installed in the workspace but is not configured to be loaded (i.e. the "python.languageServer" is set to "None"), then pyright will allow itself to be loaded.

Published 1.1.386

Bug Fixes:

• Fixed issue that results in non-deterministic false positive error, often relating to the "awaitable" check.
• Fixed bug that results in a false positive error when using a traditional generic type alias defined with a "naked" type variable surrounded by Annotated within a Python 3.12 type statement.
• Fixed a bug that leads to a false positive when using asssert_type with a **kwargs parameter that is annotated with an unpacked TypedDict.
• Fixed recent regression that results in a spurious type error when accessing an instance variable self.x if x has the type of a class-scoped type variable with a default value.
• Fixed a recent regression that results in false positive errors under certain circumstances that involve assignability checks for two callables that involve a *args: *tuple[] parameter.
• Fixed bug that results in a false positive when resolving a multi-part import target that involves a circular dependency.
• Fixed regression that results in a false positive error (and an error that is reported at a bogus location) when overriding a dataclass field with a converter.
• Fixed bug in constraint solver that resulted in behavior that differed depending on the order of methods in a protocol.
• Fixed a bug that results in a spurious error when specializing an old-style generic type alias whose type is defined as a new-style type alias that has multiple type parameters, only some of which are used in its type definition.
• Fixed bug that leads to incorrect type narrowing in the negative ("else") case when using isinstance with a filter type that is typed as type[X].
• Fixed bug that results in a false negative when the specialization of a ParamSpec results in a signature that has a duplicate parameter name where one parameter has a default value and the other does not.

Enhancements:

• Added a limit to the number of typed declarations that will be evaluated for a single symbol. This mitigates performance issues with code that redeclares a symbol hundreds or thousands of times.
• Updated support for "closed" TypedDict to match latest updates to PEP 728.
• Enhanced the type(y) == x type guard logic to support the case where y is declared as a type variable with an upper bound that overlaps with the type of x.
• Updated typeshed stubs to the latest version.
• Updated toml parser library to support toml 1.0.0 syntax.
• Removed the limitation that the "ignore" setting in a config file must be relative to the project root.

Published 1.1.385

Bug Fixes:

• Fixed bug that leads to a false positive error when using Literal[] in a value expression (not a type expression) with an unpack operator.
• Fixed a recent regression that results in a false positive in cases where a dataclass field has a default value where the expression requires bidirectional type inference for proper type evaluation.
• Fixed recent regression that results in a false negative when calling a constructor for a class with a custom metaclass with a __call__ method that has an unannotated return type if the arguments passed to the constructor are incorrect.
• Fixed bug that results in a false positive when a NamedTuple field uses ... as a default value in a stub file.
• Fixed recent regression that leads to a false positive error when assigning a generic method within a class body.
• Fixed recent regression that results in a false negative when calling a function with an *args parameter annotated with an unpacked tuple.
• Fixed bug that results in false positive error when a dataclass field is annotated with a class-scoped type variable and includes a default value whose type require bidirectional type inference.
• Fixed bug that results in incorrect type evaluation and a false negative when accessing an attribute through a TypeVar with an upper bound.
• Fixed bug that results in false positive error regarding a __bool__ method for a value used in an operand for an or or and operator.

Enhancements:

• Added check for alias keyword argument in a dataclass_transform field definition call to ensure that it's a valid Python identifier.

Published 1.1.384

Bug Fixes:

• Fixed bug that results in a false positive when Union and Unpack are used outside of a type expression. Normal type expression rules should not be applied in this case.
• Fixed bug that results in a false negative under certain circumstances when using PEP 695 syntax and a TypeVarTuple multiple times in a signature.
• Added limiter to sequence pattern matching logic to prevent a combinatoric explosion when performing tuple expansion during narrowing.
• Fixed bug that results in incorrect type narrowing on assignment if the narrowed type is Self or another bound type variable.
• Fixed a bug that leads to a false negative when a class-scoped variable is annotated with a value-constrained type variable and assigned a default value with one of the value constraints.
• Fixed bug that results in a false positive when using a traditional (non-PEP 695) TypeVar in a type expression and assigning to a TypeForm.
• Fixed recent regression that caused false positive errors with protocol matching in certain circumstances.
• Fixed bug that leads to a false positive when a callable object uses a Callable type annotation for the self parameter in its own __call__ method.
• Fixed a bug that results in the inability to rename a NamedTuple field.
• Fixed a bug that results in incorrect type evaluation when the type of a dataclass field is declared with a type variable but its default value is concrete.

Enhancements:

• Enhanced isinstance narrowing logic to retain type arguments in cases where the filter type (the second argument) is a child of the un-narrowed type and the child has a type parameter that is used multiple times in its base class (e.g. Child[T](Parent[T, T])).
• Improved determinism of type evaluations involving unions of literal by taking into consideration literal values when sorting subtypes.
• Updated typeshed stubs to the latest version.
• Added support for *args: Unpack[T] when T is a type variable with an upper bound of a tuple.

Behavior Changes:

• Removed provisional support for PEP 746 because the PEP has been modified, and there is disagreement about the best approach.
• Changed the default python version from 3.12 to 3.13, now that 3.13 is the latest stable release.

Published 1.1.383

Bug Fixes:

• Fixed a bug that resulted in an incorrect error when using a # pyright: standard directive.
• Fixed a bug that leads to incorrect type evaluation when "literal math" for unary operators are applied to a TypeVar value that has a literal value upper bound.
• Fixed bug with the provisional TypeForm support that breaks aliases of Annotated.
• Fixed bug that results in incorrect variance inference for some generic type aliases that use auto variance and nested callable types.
• Fixed bug that resulted in a false negative when assigning a specialized recursive generic type alias to itself when variance of its type parameters are not covariant.
• Fixed several bugs related to the explicit specialization of a generic type alias parameterized by a single ParamSpec. Concatenate was being handled incorrectly.
• Fixed bug that results in a false negative when a type variable is defined with the expression .... This should be flagged as an illegal type expression.
• Fixed bug that caused type alias to Never or NoReturn to lose its type alias association in some circumstances.

Enhancements:

• Improved verbose logging of execution environment information.
• Added code to propagate information about certain typing module imports from an implicitly-imported module (e.g. builtins or __builtins__.pyi) so Final and ClassVar can be treated as special forms by the binder. This fixes the use of these typing symbols in notebooks within pylance, which leverages implicitly-imported modules to "chain together" notebook cells.
• Added check for use of a TypedDict class within a case statement class pattern. This condition generates a runtime error.
• Improved type evaluation performance in certain cases involving protocol matching for complex, nested protocols.

Published 1.1.382

Bug Fixes:

• Fixed bug that can result in incorrect type evaluation behaviors if a call to type is used within a loop.
• Fixed bug that results in incorrect type inference for list, set, dict, and tuple expressions that include modules in them.
• Fixed bug that results in false positive error when using a Final variable in a protocol and a NamedTuple or frozen dataclass as a concrete class.
• Fixed bug that results in a false negative when assigning a value to a union type that includes the same type variable multiple times in at least one invariant context. This change eliminates the concept of a "locked" constraint tracker, which is no longer needed and was the underlying cause of the bug.
• Fixed bug that resulted in a "reportIncompatibleMethodOverride" error being reported in the wrong location when a property method has a decorator applied to it.
• Fixed a bug that results in a false positive when assigning Never to a type variable in a contravariant context.
• Added check for the illegal use of TypeForm as the second argument to an isinstance or issubclass call.
• Fixed bug that results in incorrect type narrowing when a value typed as TypeForm is used as the first argument to isinstance.
• Fixed a bug that can result in a false positive error when a function signature contains a positional-only parameter and a keyword parameter with the same name. This can result from the application of a ParamSpec or through the use of an unpacked TypedDict.
• Fixed a bug that results in incorrect type evaluation behaviors when a class has a custom metaclass with a __call__ method and a __new__ or __init__ method that provides a different bidirectional type inference context for parameters.

Enhancements:

• Added special-case handling for the len(t) == L type guard pattern to handle the negative narrowing case where tuple t has a minimum length of L. In this case, the narrowed type can be computed whereas previously it was left unnarrowed.
• Improved hover text for converters in dataclass-like classes.
• Updated typeshed stubs to the latest version.
• Extended reportUnnecessaryComparison to cover more cases involving is and is not operators.

Published 1.1.381

Bug Fixes:

• Fixed bug that results in incorrect type narrowing for sequence patterns in the negative (fall-through) case when the subject is a tuple with an unbounded entry.
• Fixed recent regression that results in a false positive error when attempting to assign the expression type(Any) to type type[Any].
• Fixed a bug that results in incorrect evaluation of a variable in a doubly-nested loop that is assigned a value in an assignment expression.
• Fixed a bug that results in incorrect narrowing of types for TypeIs user-defined type guard in certain cases when variable type is a union.
• [Contribution by @dcolascione] Fixed bug that results in a condition where imports stop resolving after file edits that change the set of modules that a file imports.
• Fixed recent regression that results in incorrect type narrowing for isinstance in the negative case when using type as a filter.
• Fixed bug that results in incorrect reporting of the Python version in a deprecation diagnostic message.
• Fixed bug that results in incorrect code flow involving a call to a NoReturn callable with a function decorator applied.
• Fixed bug that results in a spurious "symbol refers to itself" error under very specific conditions.
• Fixed bug that can theoretically result in spurious errors when evaluating expressions that involve parameter symbols.
• Fixed bug that results in incorrect type narrowing when TypeIs intersects type[A] with type[B]. Previously, pyright was producing <subclass of type[A] and type[B]> but now produces type[<subclass of A and B>].
• [From pylance] Fixed recent regression that caused venvPath specified in language server settings to be ignored.
• Fixed bug that results in a confusing error message extension referencing a missing __set__ method when assigning to a class variable that is not a descriptor object.
• Fixed a bug that results in a false positive type error and confusing error message when assigning to a class variable that uses Self in its type definition.
• Fixed a bug that results in spurious "variable not allowed in type expression" errors when a type alias is used in a loop in both a type expression and a value expression.

Behavior Changes:

• Updated provisional support for TypeForm based on feedback to draft PEP 747.

Enhancements:

• Expanded reportUnnecessaryIsinstance check to report cases where an isinstance or issubclass call always evaluates to False.
• Improved error message for type violation in assignment statement where the LHS is an instance variable reference.
• [From pylance] Update Unicode range tables to match Unicode 16.0, which is used for Python 3.14.