Enhancements:

• Updated typeshed stubs to the latest version

Behavior Changes:

• Removed experimental support for PEP 736, which was rejected. (#10616)

Changes:

• f584f78 Published 1.1.402
• 0246b06 Fixed bug that results in a false positive "fully overlapping overload" error when a second overload uses a Callable with a ParamSpec but the first does not. This addresses #10587. (#10588)
• ce1c735 Improved modeling of bound and unbound methods so they properly use types.MethodType or types.FunctionType. This addresses #10514. (#10586)
• 859cc50 Added support for bidirectional type inference when assigning an expression to an unpacked tuple literal and all of the items in the tuple have a declared type. This addresses #10481. (#10585)
• 4887eb7 Fixed bug that results in confusion between two classes defined in the same file with the same name but in different functions when they are used in protocol matching. This addresses #10418. (#10584)
• 4cd01c6 Revert "Added check for mutable values of type list, dict, or set when used as default values for a dataclass field. These result in TypeErrors at runtime. This addresses #10553. (#10557)"
• f326cc6 Added reportUnreachable diagnostic check. If enabled, it emits a diagnostic for code that is determined to be structurally unreachable or unreachable via type analysis. It does not report code that is within a code block that is gated by a conditional that is statically determined to be false, such as TYPE_CHECKING and version checks. This diagnostic check is off by default even in strict mode because there are legitimate reasons for unreachable code to exist in Python code. (#10581) [ #10284 ]
• c165c3f Reverted narrowing behavior for discriminating between TypedDicts. This narrowing behavior isn't technically correct from a type safety standpoint, but until PEP 728 is accepted, it's the only practical way to do this form of discrimination. This addresses #10517. (#10579)
• 8610325 Changed behavior when @final is applied to a method but subsequent decorators (like @functools.cache or @property) subsequently transform the method into a different type. The typing spec is not clear how this should work. Pyright now honors the @final in these cases, which is consistent with mypy. This addresses #10543. (#10578)
• a52db80 Fixed bug that causes bidirectional type inference to be skipped when the target of an assignment is a member access expression (base.member) and the base expression is a module. This addresses #10539. (#10577)

Bug Fixes:

• Fixed a bug in the type narrowing logic for the S in D type guard pattern (where S is a string literal and D is a TypedDict). If the TypedDict is not closed, the absence of the key within the TypedDict definition cannot eliminate the type during narrowing.
• Fixed a bug that leads to a false negative when accessing a key on a TypedDict that is defined with extra_items=Never.
• Fixed bug that results in incorrect variance inference when a property access method uses a method-local type variable to annotate the self parameter.
• Fixed bug that results in a false positive error under certain circumstances where the second argument for a super call is a union.
• Fixed bug that results in a false negative when deriving from a stdlib protocol class and not implementing one or more abstract methods.
• Fixed bug that results in incorrect type narrowing behavior when the second argument to an isinstance call includes a union (specifically with the | operator) within a tuple expression.
• Fixed a bug that results in a spurious error when __class__() is assigned to Self.
• Added missing check for unquoted self references when calling TypeAliasType constructor manually (as opposed to using the PEP 695 type syntax).
• Fixed a bug that results in incorrect expansion of the bytes promotion type if the value is a bytes literal.
• Fixed bug in type narrowing logic for class patterns in a match statement. Negative type narrowing was incorrect when the subject is a literal type and the class is the corresponding non-literal class.

Enhancements:

• Improved handling of __slots__ members to correctly model the case where a descriptor object is stored in a __slots__ variable.
• Modified --verifytypes output to expand type aliases in its error messages to help diagnose "partially unknown" conditions.
• Enhanced x is ... type narrowing logic to narrow Any | EllipsisType to EllipsisType to match x is None narrowing logic.
• Updated typeshed stubs to the latest version.

Behavior Changes:

• Switched internal usage of builtins.function, typing.AwaitableGenerator, and typing._TypedDict to types.FunctionType, _typeshed._type_checker_internals.AwaitableGenerator, and _typeshed._type_checker_internals.TypedDictFallback, respectively.

Bug Fixes:

• Fixed bug that results in a false positive when accessing a generic attribute from an object whose type is type[X].
• Fixed bug that results in incorrect type narrowing of a variable that is shadowed in an inner-scoped comprehension.
• Fixed bug that results in a false positive error when referencing a class-scoped type alias defined as a callable.
• Fixed bug that causes bidirectional type inference not to be used in cases where a ternary expression is assigned to an annotated instance or class variable and the ternary condition narrows the type of self or cls.
• Fixed bug that results in a spurious "type already specialized" error when using a class-scoped type alias defined using a type statement or TypeAliasType constructor.
• Fixed a bug that leads to a hang when a generic type alias definition refers to itself.
• Fixed a bug that results in missing diagnostic details under certain circumstances where bidirectional type inference is attempted in the assignment of an attribute.
• Fixed a bug that results in a false positive error when calling a function with an unpacked TypedDict with extra_items when additional keyword args are passed.
• [From pylance] Fixed regression introduced in 1.1.399 that caused pyright CLI to fail to run on Linux systems.

Enhancements:

• Extended "type(x) is C" type narrowing logic to support cases where C is a union of types or a type variable with a union upper bound.
• Added support for PEP 765, which makes it a syntax error (or warning) in Python 3.14 if a return, break or continue is used to exit a finally clause.
• Added check for named tuple field names that begin with an underscore. These result in a runtime exception.

Behavior Change:

• Reverted a recent change that extended the reportPrivateImportUsage check to enforce imports from submodules whose names begin with an underscore. This change was disruptive to users of the popular pandas library because it exports a submodule named _typing. This was originally intended to be experimental or private, but it was never fully addressed. The pandas maintainers will work to fix this issue (pandas-dev/pandas#55231) over the next year. I'm going to back out this change to pyright in the meantime.

Bug Fixes:

• Fixed bug that results in incorrect type narrowing when a value whose type is a non-callable (and non-final) class is passed as the second argument to an isinstance call and the first argument is a callable type. In this case, a subclass could provide a compatible __call__ method, so the type shouldn't be narrowed to Never.
• Fixed bug that results in a false positive "missing stub file" diagnostic when importing a "py.typed" submodule from a namespace package.
• Fixed bug that results in a false negative when a type variable with an upper bound is used to annotate a parameter in a method override.
• Fixed a bug that results in a false negative for a method override that uses Self in a contravariant position.
• Fixed bug that results in a false positive error under certain circumstances involving a type variable with an upper bound of type[T] that is assigned to another type variable.
• Fixed a bug that results in a false negative when the specialization of a TypeVarTuple includes multiple unpacked tuples of unknown length.
• Fixed a bug that results in a false negative when a class that derives from type[Any] is assigned to any other type.
• Fixed bug that results in an incorrect error under certain circumstances when inferring the return type of a recursive function that has a decorator or is async.
• Fixed bug that results in a false negative when a return statement contains a call expression that invokes a NoReturn call and the argument list contains errors.
• Fixed bug that leads to a false positive in the reportUnnecessaryComparison check when one operand's type is a callable and the other is not.
• [From pylance] Fixed a bug that results in an internal assertion (and therefore a crash) when __builtins__.pyi imports from a project file.

Enhancements:

• Extended deprecateTypingAliases feature to support symbols imported from typing_extensions.
• Extended reportUnknownVariableType check to include cases where a value whose type is a generic class parameterized by Unknown is assigned to a variable with a declared type.
• Extended the check for isinstance and issubclass argument validation to flag the Literal special form, which leads to a runtime error when used in the second argument.
• Updated typeshed stubs to the latest version. This version removes support for Python 3.8, which is now out of service.

Behavior Changes:

• Removed support for ru and ur string prefixes. These were supported in Python 2.7 but are syntax errors in Python 3.x.

Bug Fixes:

• Fixed bug that results in a spurious type error when a ParamSpec is used in conjunction with a dataclass and a contextmanager.
• Fixed recent regression that results in a false negative when calling a function with a positional-only parameter whose type is generic and has a concrete default argument value.
• Fixed regression that results in an Unknown type evaluation where previously Any was generated during bidirectional type inference.
• Fixed bug that results in incorrect overload resolution when an unpacked argument is of unknown length and potentially matches multiple overloads.
• Fixed bug that results in a variable being displayed as "not accessed" if it's used in an argument expression for a call expression whose base type is a module or None.
• Fixed bug that results in a hang under certain very specific circumstances involving a protocol method that has been decorated in such a way that it can no longer be bound to the owning protocol class.
• Fixed a bug that contributes to inconsistent type evaluation results when using the "--threads" feature.
• Fixed bug that results in incorrect "literal math" result when dividing Literal[0] by a negative literal int value.
• Fixed a bug in "literal math" for shift operators. If the RHS value is negative, the operation is invalid, so literal math shouldn't be applied.
• Fixed bug in "literal math" logic for modulo and floor divide operators that affect cases where operands have different signs.

Behavior Changes:

• Changed algorithm for applying type narrowing upon assignment when one or both of the declared type or assigned type contain "Any".
• Removed special-casing for async functions that skips check for implicit return when the return type is NoReturn.

Enhancements:

• Updated typeshed stubs to the latest version.
• Extended reportPrivateImportUsage to report the use of symbols imported from private submodules in a "py.typed" or stub library.
• Extended the reportUnnecessaryComparision check to support the patterns x is None and x is not None in cases where x is provably disjoint in type.
• Added generalized support for assignment expressions (walrus operators) for type guards.
• Extended the type narrowing logic for the x == L type guard pattern so it supports the case where x is LiteralString and L is a string literal.

Bug Fixes:

• [From pylance] Fix problem with partial stub service not being part of Pyright CLI.
• Added additional special-casing to x in y type guard logic to handle LiteralString values.
• Partially eliminated inconsistent error reporting when calling a function with a default argument that is not assignable to the declared parameter type. An error will still be reported in the case where the declared parameter type includes an unsolved type variable in most cases, but it will no longer be reported if the unsolved type variable is due to a pseudo-generic class.
• Fixed bug that results in an identifier being marked "unaccessed" if it is used in an argument expression to a call whose type is possibly unbound.
• Fixed bug that leads to a false negative when evaluating a call expression where the callable type is Any and an argument expression uses dictionary unpacking but the operands type is not a mapping.
• Fixed a bug that results in an incorrect "Unknown" type evaluation under certain circumstances involving an assignment to an annotated variable within a loop.
• Fixed bug that results in incorrect bidirectional type inference when using nested constructor calls for dataclasses.
• Fixed a bug that results in incorrect "literal math" results when using a floor divide // operator with literal operands whose signs differ.
• Fixed a bug that results in a hang under certain circumstances when inferring the return type of a recursive function.

Enhancements:

• Changed type evaluator to make a best effort to evaluate the return type of a function call even if arguments are missing.
• [From pylance] Implement support for pull diagnostics in pyright.
• Added code to enforce that an argument in a call expression that is unpacked is iterable.
• Improved support for unused import detection for import statements that target multi-part names.

Behavior Changes:

• Changed the type of __path__ from Iterable[str] to MutableSequence[str]. Both are correct, but the latter is more precise.
• Improved determinism of --threads diagnostic output by always sorting output by file path.
• Improved reproducibility of CLI diagnostics in non-threaded case by sorting output by file path.

This is a hot fix release that addresses a regression introduced in 1.1.395 that affected several popular libraries including pandas.

Bug Fixes:

• Reverted previous bug fix that caused errors to be detected and reported in cases where a library defines a function or method with one or more typed parameters with default arguments whose types are incompatible with the parameter type. Previously, pyright reported these errors in some cases but not in others. The bug fix caused these errors to be consistently reported. However, an unexpected number of libraries are impacted by this change. This reversion will give us time to better understand the extend of the issue and determine the correct long-term solution.

Enhancements:

• Added bidirectional type inference for container types that are parameterized by a protocol that matches a module.

Bug Fixes:

• Fixed a bug that results in noncompliance with the typing spec when a __new__ method has an explicit Any return type annotation. In this case, type checkers should assume that the return type of __new__ is not a subtype of the containing class and should therefore ignore the __init__ method.
• Fixed bug that results in a spurious "overlapping overload" error if the second both overloads have an *args but the first has one or more additional positional parameters
• Fixed bug that leads to inconsistent behavior in certain cases involving the evaluation of a call whose target signature involves a parameter with a default argument value, notably where the type of the default value isn't assignable to the declared type of its parameter.
• Fixed a bug that results in a spurious reportUnknownArgumentType error under certain circumstances.
• Fixed a bug that resulted in a spurious error under certain specific conditions involving a call to a function or method that doesn't have a return type and whose inferred return type is based on variables calculated in a loop.
• Fixed a bug that results in an incorrect error when determining assignability of a function with an *args that is unpacked using a *tuple[].
• Fixed bug that results in a spurious error when an isinstance or issubclass type guard results in a narrowed type that is synthesized as a subclass of type and some other class.
• Fixed a bug that results in a spurious error when an unpacked iterable argument expression supplies the objects for an *args parameter that is annotated with an unpacked TypeVarTuple.

Behavior Changes:

• Exempted __init__ from override checks even in the case when the override is an object (such as a context manager) rather than a function.
• Added special-case logic to permit type[T] to be treated as assignable to TypeForm[T] in accordance with the latest draft of PEP 747.
• Changed the interpretation of an async function with an empty body (no yield statement) in a stub file or protocol definition that has a return type annotation of AsyncGenerator. Previously, this was assumed to be a generator even though a yield statement wasn't present. It is now assumed to be a Coroutine. This behavior is not spelled out in the typing spec, but pyright's new behavior is now consistent with mypy's.

Enhancements:

• Improved error reporting for PEP 728 features when enableExperimentalFeatures is not true.
• Added error check for member access expressions that attempt to bind an instance or class method to an object or class when the method accepts no "self" or "cls" parameter.
• Added check for invalid creation of TypeAliasType outside of a class or module scope.
• Updated typeshed stubs to the latest version.
• Added special-case logic to allow Any to be defined in typing.pyi using a class statement rather than how it has traditionally been defined.

Enhancements:

• Added missing check for a PEP 695 type parameter being the target of a nonlocal statement. This results in a runtime exception, so it should be reported as an error.
• Improved error message for TypedDict base classes that are not closed but specify an extra_items. Also added check for cases where closed and extra_items are both specified.
• Updated typeshed stubs to the latest version.
• Added missing check for the override of a property that is marked @final.
• Added support for tracking multiple constraint sets when performing protocol matching. This allows protocols with overloaded methods to contribute independent constraint sets.

Bug Fixes:

• Fixed a bug that results in incorrect handling (and spurious errors) when accessing an attribute on a TypedDict that is shadowed by a TypedDict item.
• Fixed a spec conformance issue relating to callable assignability when the dest type uses an unpacked TypedDict and the source does not accept **kwargs. The typing spec indicates that this should fail because TypedDicts are not closed.
• Fixed bug that results in incorrect inferred type for an instance or class variable assigned a value as part of a tuple expression target with an unpack operator (e.g. a, *self.b = (1, 2, 3)).
• Fixed bug that resulted in incorrect type inference for unannotated variables (either local or class-scoped) that are the target of an augmented assignment.
• Fixed a bug that leads to a false negative when checking for partially overlapping overloads that have keyword parameters with default argument values.
• Fixed a bug that causes a false positive "no overload implementation" error when a non-overloaded function uses a decorator that changes its type to a an overloaded function.
• Fixed bug that results in false negative when a format string with a single quote has a newline character within it. This results in a syntax error at runtime.
• Fixed regression that resulted in a false positive error when evaluating a call expression that targets an overloaded method and one of the arguments is an enum with more than 64 members.
• Fixed a bug that results in a false positive "overlapping overload" error under certain circumstances involving recursive types.
• Fixed a bug that results in a false positive error when assigning a tuple of indeterminate length to a zero-length tuple target.
• Fixed a bug that leads to incorrect (unsound) type narrowing when using the x in y type guard pattern. The in operator uses equality checks, and __eq__ can succeed for objects of disjoint types, which means disjointedness cannot be used as the basis for narrowing here. This change also affects the reportUnnecessaryContains check, which leverages the same logic.
• Fixed recent regression that affected the evaluation of calls that target certain overloads that include an *args parameter in the fallback (the last overload). In particular, this affected the zip constructor.
• Removed errant check for @final consistency when it is applied to TypedDict.
• Fixed a bug that results in incomplete renames when renaming a class or function that uses PEP 695 type parameter syntax.

Behavior Changes:

• Changed behavior of TypedDict to synthesize a fall-back overload for the pop method to handle the case where the caller passes a key name that is not specified in the TypedDict definition.
• Changed the type of an async def function from typing.Coroutine to types.CoroutineType for improved type accuracy.
• Exempted __slots__ symbol when determining whether a class is a callback protocol.