Merge branch 'master' into sentinels-reloaded

Author: edgarrmondragon

CHANGELOG.md

@@ -2,6 +2,86 @@
 
 ## Next Release
 
+## Mypy 2.1
+
+We’ve just uploaded mypy 2.1.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
+Mypy is a static type checker for Python. This release includes new features, performance
+improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### librt.vecs: Fast Growable Array Type for Mypyc
+
+The new `librt.vecs` module provides an efficient growable array type `vec` that is
+optimized for mypyc use. It provides fast, packed arrays with integer and floating point
+value types, which can be **several times faster** than `list`, and tens of times faster
+than `array.array` in code compiled using mypyc. It also supports nested `vec` objects and
+non-value-type items, such as ``vec[vec[str]]``.
+
+Refer to the [documentation](https://mypyc.readthedocs.io/en/latest/librt_vecs.html) for
+the details.
+
+Contributed by Jukka Lehtosalo.
+
+### librt.random: Fast Pseudo-Random Number Generation
+
+The new `librt.random` module provides fast pseudo-random number generation that is
+optimized for code compiled using mypyc. It can be 3x to 10x faster than the stdlib
+`random` module in compiled code.
+
+Refer to the [documentation](https://mypyc.readthedocs.io/en/latest/librt_random.html) for
+the details.
+
+Contributed by Jukka Lehtosalo (PR [21433](https://github.com/python/mypy/pull/21433)).
+
+### Mypyc Improvements
+
+- Enable incremental self-compilation (Vaggelis Danias, PR [21369](https://github.com/python/mypy/pull/21369))
+- Make compilation order with multiple files consistent (Piotr Sawicki, PR [21419](https://github.com/python/mypy/pull/21419))
+- Fix crash on accessing `StopAsyncIteration` (Piotr Sawicki, PR [21406](https://github.com/python/mypy/pull/21406))
+- Fix incremental compilation with `separate` flag (Vaggelis Danias, PR [21299](https://github.com/python/mypy/pull/21299))
+
+### Fixes to Crashes
+
+- Fix crash on partial type with `--allow-redefinition` and `global` declaration (Jukka Lehtosalo, PR [21428](https://github.com/python/mypy/pull/21428))
+- Fix broken awaitable generator patching (Ivan Levkivskyi, PR [21435](https://github.com/python/mypy/pull/21435))
+
+### Changes to Messages
+
+- Fix function call error message for small number of arguments (sobolevn, PR [21432](https://github.com/python/mypy/pull/21432))
+
+### Other Notable Fixes and Improvements
+
+- Rely on typeshed stubs for `slice` typing (Ivan Levkivskyi, PR [21401](https://github.com/python/mypy/pull/21401))
+- Narrow match captures based on previous cases (Shantanu, PR [21405](https://github.com/python/mypy/pull/21405))
+- Fix nondeterminism in overload resolution (Shantanu, PR [21455](https://github.com/python/mypy/pull/21455))
+- Respect file config comments for stale modules (Adam Turner, PR [21444](https://github.com/python/mypy/pull/21444))
+- Fix JSON output mode for syntax errors in parallel mode (Adam Turner, PR [21434](https://github.com/python/mypy/pull/21434))
+- Fix type variable with values as a supertype (Ivan Levkivskyi, PR [21431](https://github.com/python/mypy/pull/21431))
+- Add support for configuring `--num-workers` with an environment variable (Kevin Kannammalil, PR [21407](https://github.com/python/mypy/pull/21407))
+- Respect JSON output mode for syntax errors (Adam Turner, PR [21386](https://github.com/python/mypy/pull/21386))
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=e4d32e01bee44241a5e7c33298c261175b9f1bdb+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+- Adam Turner
+- Ivan Levkivskyi
+- Jukka Lehtosalo
+- Kevin Kannammalil
+- Piotr Sawicki
+- Shantanu
+- sobolevn
+- Vaggelis Danias
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
 ## Mypy 2.0
 
 We’ve just uploaded mypy 2.0.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).

CONTRIBUTING.md

@@ -123,6 +123,18 @@ tox -e dev --override testenv:dev.allowlist_externals+=env -- env  # inspect the
 If you don't already have `tox` installed, you can use a virtual environment as
 described above to install `tox` via `pip` (e.g., ``python -m pip install tox``).
 
+## LLM-assisted contributions
+
+In general, mypy takes a neutral stance on using various LLM code assistants to
+make contributions. LLMs are just another tool, and contributors bear full
+responsibility for the code they are submitting. Disclosing the use of LLMs in
+pull request description is recommended, but not required.
+
+However, we discourage use of LLMs by *new* contributors. We are interested in
+growing long-term contributors who have good understanding of mypy code.
+Pull requests from new contributors that are mostly generated by LLMs
+with little human input will be closed.
+
 ## First time contributors
 
 If you're looking for things to help with, browse our [issue tracker](https://github.com/python/mypy/issues)!

docs/source/error_code_list2.rst

@@ -550,7 +550,7 @@ Example:
 Check that overrides of mutable attributes are safe [mutable-override]
 ----------------------------------------------------------------------
 
-`mutable-override` will enable the check for unsafe overrides of mutable attributes.
+``mutable-override`` will enable the check for unsafe overrides of mutable attributes.
 For historical reasons, and because this is a relatively common pattern in Python,
 this check is not enabled by default. The example below is unsafe, and will be
 flagged when this error code is enabled:

docs/source/kinds_of_types.rst

@@ -443,7 +443,7 @@ case you should add an explicit ``... | None`` annotation.
    The Python interpreter internally uses the name ``NoneType`` for
    the type of ``None``, but ``None`` is always used in type
    annotations. The latter is shorter and reads better. (``NoneType``
-   is available as :py:data:`types.NoneType` on Python 3.10+, but is
+   is available as :py:class:`types.NoneType` on Python 3.10+, but is
    not exposed at all on earlier versions of Python.)
 
 .. note::

docs/source/more_types.rst

@@ -573,7 +573,7 @@ implementation, then the body is not type checked. If you want to
 force mypy to check the body anyways, use the :option:`--check-untyped-defs <mypy --check-untyped-defs>`
 flag (:ref:`more details here <untyped-definitions-and-calls>`).
 
-The variants must also also be compatible with the implementation
+The variants must also be compatible with the implementation
 type hints. In the ``MyList`` example, mypy will check that the
 parameter type ``int`` and the return type ``T`` are compatible with
 ``int | slice`` and ``T | Sequence`` for the

docs/source/typed_dict.rst

@@ -81,9 +81,9 @@ arbitrarily complex types. For example, you can define nested
 ``TypedDict``\s and containers with ``TypedDict`` items.
 Unlike most other types, mypy uses structural compatibility checking
 (or structural subtyping) with ``TypedDict``\s. A ``TypedDict`` object with
-extra items is compatible with (a subtype of) a narrower
+extra items can be compatible with (a subtype of) a narrower
 ``TypedDict``, assuming item types are compatible (*totality* also affects
-subtyping, as discussed below).
+subtyping, as does *closing*, as discussed below).
 
 A ``TypedDict`` object is not a subtype of the regular ``dict[...]``
 type (and vice versa), since :py:class:`dict` allows arbitrary keys to be
@@ -276,6 +276,84 @@ vary :ref:`covariantly <variance-of-generics>`:
     m: Movie = {"name": "Jaws", "year": 1975}
     process_entry(m)  # OK
 
+You can override a read-only item with a compatible subtype, make a
+read-only item mutable, and inherit from multiple parents with compatible
+definitions:
+
+.. code-block:: python
+
+    from collections.abc import Collection, Sequence
+
+    class Competition(TypedDict):
+        hosts: ReadOnly[Collection[str]]
+        entries: ReadOnly[Sequence[Entry]]
+
+    class MovieShow(TypedDict):
+        entries: list[Movie]
+
+    class Oscars(Competition, MovieShow):
+        hosts: set[str]
+
+Defining ``hosts`` as a mutable ``set[str]`` item works as this is compatible
+with the read-only ``Collection[str]`` definition in ``Competition``.
+``entries`` will be of type ``list[Movie]``, taken from the ``MovieShow`` type,
+as it is the only non-readonly definition, and is compatible with the definition
+in ``Competition``.
+
+If an item is only defined in supertypes, and is always read-only, mypy takes
+the definition from the first parent in the inheritance order, and raises an
+error if any other parent definition is incompatible:
+
+.. code-block:: python
+
+    class NameIds(TypedDict):
+        ids: ReadOnly[Collection[str]]
+
+    class OrderedIds(TypedDict):
+        ids: ReadOnly[Sequence[int | str]]
+
+    class OrderedNameIds(NameIds, OrderedIds):
+        pass  # Error! Parent definitions incompatible
+
+In this example, the definition of ``ids`` will be taken from ``NameIds``,
+which would not be compatible with the definition in ``OrderedIds``; reordering
+the parents would not solve the problem. Instead, you will need to make a
+compatible definition explicitly:
+
+.. code-block:: python
+
+    class OrderedNameIds(NameIds, OrderedIds):
+        ids: ReadOnly[Sequence[str]]
+
+Closing
+-------
+
+You can use the ``closed`` keyword, introduced to ``TypedDict`` in Python
+3.15 (and available via ``typing_extensions.TypedDict`` in older
+versions) to prevent structural subtypes from adding extra keys to a
+type (:pep:`728`):
+
+.. code-block:: python
+
+   HasName = TypedDict("HasName", {"name": str})
+   HasOnlyName = TypedDict("HasOnlyName", {"name": str}, closed=True)
+   Movie = TypedDict("Movie", {"name": str, "year": int})
+
+   movie: Movie = {"name": "Nimona", "year": 2023}
+   has_name: HasName = movie  # OK: type is open
+   has_only_name: HasOnlyName = movie  # Error: type is closed
+
+This allows the typechecker to determine that certain operations are safe,
+when they otherwise wouldn't be due to the potential presence of unknown
+keys.
+
+The ``closed`` keyword can also be used in class-based syntax:
+
+.. code-block:: python
+
+   class HasOnlyName(TypedDict, closed=True):
+       name: str
+
 Unions of TypedDicts
 --------------------
 
@@ -289,6 +367,40 @@ need to give each TypedDict the same key where each value has a unique
 :ref:`Literal type <literal_types>`. Then, check that key to distinguish
 between your TypedDicts.
 
+Alternatively, you can implement tagged unions with single-key wrapper dictionaries:
+
+.. code-block:: python
+
+   class Book(TypedDict):
+       name: str
+       length: int
+       ...
+
+   class DVD(TypedDict):
+       name: str
+       length: int
+       ...
+
+   TaggedBook = TypedDict('TaggedBook', {'book': Book}, closed=True)
+   TaggedDVD = TypedDict('TaggedDVD', {'dvd': DVD}, closed=True)
+   type Inventory = TaggedBook | TaggedDVD
+
+   def print_length(inventory: Inventory) -> None:
+       if "book" in inventory:
+           print(inventory["book"]["length"], 'pages')
+       else:
+           print(inventory["dvd"]["length"], 'minutes')
+
+Here, the ``closed`` keyword is necessary to allow the ``if`` guard to safely
+narrow the types; without it, there could be a structural subtype of ``TaggedDVD``
+that contains a ``book`` field of arbitrary type.
+
+.. note::
+
+   Applying ``@final`` to a TypedDict is a legacy way of marking it as closed
+   for the purposes of type narrowing. It was never fully implemented and is
+   now superseded; it may be removed in future.
+
 Inline TypedDict types
 ----------------------
 

misc/dump-ast.py

@@ -19,7 +19,7 @@ def dump(fname: str, python_version: tuple[int, int], quiet: bool = False) -> No
     options.python_version = python_version
     with open(fname, "rb") as f:
         s = f.read()
-        tree = parse(s, fname, None, errors=Errors(options), options=options, file_exists=True)
+        tree = parse(s, fname, None, errors=Errors(options), options=options)
         if not quiet:
             print(tree)
 

misc/typeshed_patches/0001-Adjust-stubs-to-fix-mypy-lookup-error-due-to-circula.patch

@@ -1,23 +1,86 @@
-From 5c922a2484f2e18c7f901e62bb499b6414cf1090 Mon Sep 17 00:00:00 2001
+From 8985351bf6f917db1a7b15ffed95ec2357d9819d Mon Sep 17 00:00:00 2001
 From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
-Date: Wed, 18 Feb 2026 13:11:02 +0100
+Date: Mon, 18 May 2026 17:33:09 +0200
 Subject: [PATCH] Adjust stubs to fix mypy lookup error due to circular
  dependencies in stubs
 
 ---
- mypy/typeshed/stdlib/time.pyi | 6 +++---
- 1 file changed, 3 insertions(+), 3 deletions(-)
+ mypy/typeshed/stdlib/__future__.pyi | 2 +-
+ mypy/typeshed/stdlib/dis.pyi        | 4 ++--
+ mypy/typeshed/stdlib/inspect.pyi    | 4 ++--
+ mypy/typeshed/stdlib/itertools.pyi  | 2 +-
+ mypy/typeshed/stdlib/time.pyi       | 6 +++---
+ 5 files changed, 9 insertions(+), 9 deletions(-)
 
+diff --git a/mypy/typeshed/stdlib/__future__.pyi b/mypy/typeshed/stdlib/__future__.pyi
+index aa445d22b..a90cf1edd 100644
+--- a/mypy/typeshed/stdlib/__future__.pyi
++++ b/mypy/typeshed/stdlib/__future__.pyi
+@@ -1,4 +1,4 @@
+-from typing import TypeAlias
++from typing_extensions import TypeAlias
+ 
+ _VersionInfo: TypeAlias = tuple[int, int, int, str, int]
+ 
+diff --git a/mypy/typeshed/stdlib/dis.pyi b/mypy/typeshed/stdlib/dis.pyi
+index 984f932e3..0ad928934 100644
+--- a/mypy/typeshed/stdlib/dis.pyi
++++ b/mypy/typeshed/stdlib/dis.pyi
+@@ -2,7 +2,7 @@ import sys
+ import types
+ from collections.abc import Callable, Iterator
+ from opcode import *  # `dis` re-exports it as a part of public API
+-from typing import IO, Any, Final, NamedTuple, TypeAlias, overload
++from typing import IO, Any, Final, NamedTuple, overload
+ from typing_extensions import Self, deprecated, disjoint_base
+ 
+ __all__ = [
+@@ -41,7 +41,7 @@ else:
+ 
+ # Strictly this should not have to include Callable, but mypy doesn't use FunctionType
+ # for functions (python/mypy#3171)
+-_HaveCodeType: TypeAlias = types.MethodType | types.FunctionType | types.CodeType | type | Callable[..., Any]
++_HaveCodeType = types.MethodType | types.FunctionType | types.CodeType | type | Callable[..., Any]
+ 
+ if sys.version_info >= (3, 11):
+     class Positions(NamedTuple):
+diff --git a/mypy/typeshed/stdlib/inspect.pyi b/mypy/typeshed/stdlib/inspect.pyi
+index cc39a7c9f..0ca4cff75 100644
+--- a/mypy/typeshed/stdlib/inspect.pyi
++++ b/mypy/typeshed/stdlib/inspect.pyi
+@@ -196,8 +196,8 @@ if sys.version_info >= (3, 14):
+ 
+ modulesbyfile: dict[str, Any]
+ 
+-_GetMembersPredicateTypeGuard: TypeAlias = Callable[[Any], TypeGuard[_T]]
+-_GetMembersPredicateTypeIs: TypeAlias = Callable[[Any], TypeIs[_T]]
++_GetMembersPredicateTypeGuard = Callable[[Any], TypeGuard[_T]]
++_GetMembersPredicateTypeIs = Callable[[Any], TypeIs[_T]]
+ _GetMembersPredicate: TypeAlias = Callable[[Any], bool]
+ _GetMembersReturn: TypeAlias = list[tuple[str, _T]]
+ 
+diff --git a/mypy/typeshed/stdlib/itertools.pyi b/mypy/typeshed/stdlib/itertools.pyi
+index d26a4e1da..60e79bc2e 100644
+--- a/mypy/typeshed/stdlib/itertools.pyi
++++ b/mypy/typeshed/stdlib/itertools.pyi
+@@ -23,7 +23,7 @@ _T10 = TypeVar("_T10")
+ 
+ _Step: TypeAlias = SupportsFloat | SupportsInt | SupportsIndex | SupportsComplex
+ 
+-_Predicate: TypeAlias = Callable[[_T], object]
++_Predicate = Callable[[_T], object]
+ 
+ # Technically count can take anything that implements a number protocol and has an add method
+ # but we can't enforce the add method
 diff --git a/mypy/typeshed/stdlib/time.pyi b/mypy/typeshed/stdlib/time.pyi
-index 64a009318..d0853792b 100644
+index ac53089b8..9b5344b32 100644
 --- a/mypy/typeshed/stdlib/time.pyi
 +++ b/mypy/typeshed/stdlib/time.pyi
-@@ -1,16 +1,16 @@
+@@ -1,15 +1,15 @@
  import sys
  from _typeshed import structseq
--from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, final, type_check_only
-+from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, Union, final, type_check_only
- from typing_extensions import TypeAlias
+-from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeAlias, final, type_check_only
++from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeAlias, Union, final, type_check_only
 
  _TimeTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int]
 
@@ -33,5 +96,5 @@ index 64a009318..d0853792b 100644
  altzone: int
  daylight: int
 -- 
-2.53.0
+2.54.0