Merge branch 'main' into alex/mapping-update

Author: AlexWaygood

requirements-tests.txt

@@ -21,7 +21,7 @@ stubdefaulter==0.1.0; python_version < "3.14"
 termcolor>=2.3
 tomli==2.2.1; python_version < "3.11"
 tomlkit==0.13.3
-typing_extensions>=4.14.0rc1
+typing_extensions>=4.15.0rc1
 uv==0.8.6
 
 # Utilities for typeshed infrastructure scripts.

stdlib/_typeshed/__init__.pyi

@@ -3,7 +3,7 @@
 # See the README.md file in this directory for more information.
 
 import sys
-from collections.abc import Awaitable, Callable, Iterable, Sequence, Set as AbstractSet, Sized
+from collections.abc import Awaitable, Callable, Iterable, Iterator, Sequence, Set as AbstractSet, Sized
 from dataclasses import Field
 from os import PathLike
 from types import FrameType, TracebackType
@@ -275,6 +275,16 @@ class SupportsWrite(Protocol[_T_contra]):
 class SupportsFlush(Protocol):
     def flush(self) -> object: ...
 
+# Suitable for dictionary view objects
+class Viewable(Protocol[_T_co]):
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T_co]: ...
+
+class SupportsGetItemViewable(Protocol[_KT, _VT_co]):
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
+
 # Unfortunately PEP 688 does not allow us to distinguish read-only
 # from writable buffers. We use these aliases for readability for now.
 # Perhaps a future extension of the buffer protocol will allow us to

stdlib/logging/config.pyi

@@ -106,7 +106,7 @@ class ConvertingTuple(tuple[Any, ...], ConvertingMixin):  # undocumented
     @overload
     def __getitem__(self, key: slice) -> Any: ...
 
-class BaseConfigurator:  # undocumented
+class BaseConfigurator:
     CONVERT_PATTERN: Pattern[str]
     WORD_PATTERN: Pattern[str]
     DOT_PATTERN: Pattern[str]
@@ -115,6 +115,8 @@ class BaseConfigurator:  # undocumented
     value_converters: dict[str, str]
     importer: Callable[..., Any]
 
+    config: dict[str, Any]  # undocumented
+
     def __init__(self, config: _DictConfigArgs | dict[str, Any]) -> None: ...
     def resolve(self, s: str) -> Any: ...
     def ext_convert(self, value: str) -> Any: ...

stdlib/typing.pyi

@@ -5,7 +5,7 @@ import collections  # noqa: F401  # pyright: ignore[reportUnusedImport]
 import sys
 import typing_extensions
 from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import IdentityFunction, ReadableBuffer, SupportsGetItem, SupportsKeysAndGetItem
+from _typeshed import IdentityFunction, ReadableBuffer, SupportsGetItem, SupportsGetItemViewable, SupportsKeysAndGetItem, Viewable
 from abc import ABCMeta, abstractmethod
 from re import Match as Match, Pattern as Pattern
 from types import (
@@ -703,11 +703,11 @@ class MutableSet(AbstractSet[_T]):
     def __isub__(self, it: AbstractSet[Any]) -> typing_extensions.Self: ...
 
 class MappingView(Sized):
-    def __init__(self, mapping: Mapping[Any, Any]) -> None: ...  # undocumented
+    def __init__(self, mapping: Sized) -> None: ...  # undocumented
     def __len__(self) -> int: ...
 
 class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co, _VT_co]):
-    def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ...  # undocumented
+    def __init__(self, mapping: SupportsGetItemViewable[_KT_co, _VT_co]) -> None: ...  # undocumented
     def __and__(self, other: Iterable[Any]) -> set[tuple[_KT_co, _VT_co]]: ...
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
     def __contains__(self, item: tuple[object, object]) -> bool: ...  # type: ignore[override]
@@ -720,7 +720,7 @@ class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co,
     def __rxor__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
 
 class KeysView(MappingView, AbstractSet[_KT_co]):
-    def __init__(self, mapping: Mapping[_KT_co, Any]) -> None: ...  # undocumented
+    def __init__(self, mapping: Viewable[_KT_co]) -> None: ...  # undocumented
     def __and__(self, other: Iterable[Any]) -> set[_KT_co]: ...
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
     def __contains__(self, key: object) -> bool: ...
@@ -733,7 +733,7 @@ class KeysView(MappingView, AbstractSet[_KT_co]):
     def __rxor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
 
 class ValuesView(MappingView, Collection[_VT_co]):
-    def __init__(self, mapping: Mapping[Any, _VT_co]) -> None: ...  # undocumented
+    def __init__(self, mapping: SupportsGetItemViewable[Any, _VT_co]) -> None: ...  # undocumented
     def __contains__(self, value: object) -> bool: ...
     def __iter__(self) -> Iterator[_VT_co]: ...
 

stdlib/typing_extensions.pyi

@@ -120,6 +120,7 @@ __all__ = [
     "clear_overloads",
     "dataclass_transform",
     "deprecated",
+    "disjoint_base",
     "Doc",
     "evaluate_forward_ref",
     "get_overloads",
@@ -150,6 +151,7 @@ __all__ = [
     "TypeGuard",
     "TypeIs",
     "TYPE_CHECKING",
+    "type_repr",
     "Never",
     "NoReturn",
     "ReadOnly",
@@ -219,6 +221,7 @@ runtime = runtime_checkable
 Final: _SpecialForm
 
 def final(f: _F) -> _F: ...
+def disjoint_base(cls: _TC) -> _TC: ...
 
 Literal: _SpecialForm
 
@@ -616,7 +619,7 @@ TypeForm: _SpecialForm
 if sys.version_info >= (3, 14):
     from typing import evaluate_forward_ref as evaluate_forward_ref
 
-    from annotationlib import Format as Format, get_annotations as get_annotations
+    from annotationlib import Format as Format, get_annotations as get_annotations, type_repr as type_repr
 else:
     class Format(enum.IntEnum):
         VALUE = 1
@@ -684,6 +687,7 @@ else:
         format: Format | None = None,
         _recursive_guard: Container[str] = ...,
     ) -> AnnotationForm: ...
+    def type_repr(value: object) -> str: ...
 
 # PEP 661
 class Sentinel:

stubs/flake8-builtins/METADATA.toml

@@ -1,3 +1,3 @@
-version = "2.5.*"
+version = "3.0.*"
 upstream_repository = "https://github.com/gforcada/flake8-builtins"
 requires = ["types-flake8"]

stubs/flake8-builtins/flake8_builtins.pyi

@@ -18,6 +18,9 @@ class BuiltinsChecker:
     module_name_msg: ClassVar[str]
     lambda_argument_msg: ClassVar[str]
 
+    default_line_number: ClassVar[int]
+    default_column_offset: ClassVar[int]
+
     names: ClassVar[list[str]]
     ignore_list: ClassVar[set[str]]
     ignored_module_names: ClassVar[set[str]]

stubs/networkx/networkx/_typing.pyi

@@ -1,13 +1,29 @@
 # Stub-only module, can't be imported at runtime.
 
-from typing import TypeVar
-from typing_extensions import TypeAlias
+import sys
+from collections.abc import Collection
+from typing import Any, Protocol, type_check_only
+from typing_extensions import TypeAlias, TypeVar
 
 import numpy as np
 
-_G = TypeVar("_G", bound=np.generic)
+_ScalarT = TypeVar("_ScalarT", bound=bool | int | float | complex | str | bytes | np.generic)
+_GenericT = TypeVar("_GenericT", bound=np.generic)
+_GenericT_co = TypeVar("_GenericT_co", bound=np.generic, covariant=True)
+_ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], default=Any, covariant=True)
 
 # numpy aliases
-Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_G]]
-Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_G]]
+if sys.version_info >= (3, 10):
+    @type_check_only
+    class SupportsArray(Protocol[_GenericT_co, _ShapeT_co]):
+        def __array__(self) -> np.ndarray[_ShapeT_co, np.dtype[_GenericT_co]]: ...
+
+    ArrayLike1D: TypeAlias = Collection[_ScalarT] | SupportsArray[_GenericT, tuple[int]]
+else:
+    # networkx does not support Python 3.9 but pyright still runs on 3.9 in CI
+    # See https://github.com/python/typeshed/issues/10722
+    ArrayLike1D: TypeAlias = Collection[_ScalarT] | np.ndarray[tuple[int], np.dtype[_GenericT]]
+
+Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_GenericT]]
+Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_GenericT]]
 Seed: TypeAlias = int | np.random.Generator | np.random.RandomState

stubs/networkx/networkx/drawing/layout.pyi

@@ -1,7 +1,12 @@
-from _typeshed import Incomplete
+from collections.abc import Collection, Mapping
+from typing import Any, Literal
+from typing_extensions import TypeAlias
 
+import numpy as np
+from networkx._typing import Array1D, Array2D, ArrayLike1D, Seed
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
-from numpy.random import RandomState
+from numpy.typing import NDArray
 
 __all__ = [
     "bipartite_layout",
@@ -22,99 +27,134 @@ __all__ = [
     "arf_layout",
 ]
 
+_FloatArrayLike1D: TypeAlias = ArrayLike1D[float, np.number[Any]]  # Any because we don't care about the bit base
+
 def random_layout(
-    G, center=None, dim: int = 2, seed: int | RandomState | None = None, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    center: _FloatArrayLike1D | None = None,
+    dim: int = 2,
+    seed: Seed | None = None,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float32]]: ...
 def circular_layout(
-    G, scale: float = 1, center=None, dim: int = 2, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node], scale: float = 1, center: _FloatArrayLike1D | None = None, dim: int = 2, store_pos_as: str | None = None
+) -> dict[_Node, Array1D[np.float64]]: ...
 def shell_layout(
-    G, nlist=None, rotate=None, scale: float = 1, center=None, dim: int = 2, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    nlist: Collection[Collection[_Node]] | None = None,
+    rotate: float | None = None,
+    scale: float = 1,
+    center: _FloatArrayLike1D | None = None,
+    dim: int = 2,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float64]]: ...
 def bipartite_layout(
-    G,
-    nodes=None,
-    align: str = "vertical",
+    G: Graph[_Node],
+    nodes: Collection[_Node] | None = None,
+    align: Literal["vertical", "horizontal"] = "vertical",
     scale: float = 1,
-    center=None,
+    center: _FloatArrayLike1D | None = None,
     aspect_ratio: float = ...,
     store_pos_as: str | None = None,
-) -> dict[Incomplete, Incomplete]: ...
+) -> dict[_Node, Array1D[np.float64]]: ...
 def spring_layout(
-    G,
-    k=None,
-    pos=None,
-    fixed=None,
+    G: Graph[_Node],
+    k: float | None = None,
+    pos: Mapping[_Node, Collection[float]] | None = None,
+    fixed: Collection[_Node] | None = None,
     iterations: int = 50,
     threshold: float = 0.0001,
-    weight: str = "weight",
-    scale: float = 1,
-    center=None,
+    weight: str | None = "weight",
+    scale: float | None = 1,
+    center: _FloatArrayLike1D | None = None,
     dim: int = 2,
-    seed: int | RandomState | None = None,
+    seed: Seed | None = None,
     store_pos_as: str | None = None,
     *,
-    method: str = "auto",
+    method: Literal["auto", "force", "energy"] = "auto",
     gravity: float = 1.0,
-) -> dict[Incomplete, Incomplete]: ...
+) -> dict[_Node, Array1D[np.float64]]: ...
 
 fruchterman_reingold_layout = spring_layout
 
 def kamada_kawai_layout(
-    G, dist=None, pos=None, weight: str = "weight", scale: float = 1, center=None, dim: int = 2, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    dist: Mapping[_Node, Mapping[_Node, float]] | None = None,
+    pos: Mapping[_Node, Collection[float]] | None = None,
+    weight: str | None = "weight",
+    scale: float = 1,
+    center: _FloatArrayLike1D | None = None,
+    dim: int = 2,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float64]]: ...
 def spectral_layout(
-    G, weight: str = "weight", scale: float = 1, center=None, dim: int = 2, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    weight: str | None = "weight",
+    scale: float = 1,
+    center: _FloatArrayLike1D | None = None,
+    dim: int = 2,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float64]]: ...
 def planar_layout(
-    G, scale: float = 1, center=None, dim: int = 2, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node], scale: float = 1, center: _FloatArrayLike1D | None = None, dim: int = 2, store_pos_as: str | None = None
+) -> dict[_Node, Array1D[np.float64]]: ...
 def spiral_layout(
-    G,
+    G: Graph[_Node],
     scale: float = 1,
-    center=None,
+    center: _FloatArrayLike1D | None = None,
     dim: int = 2,
     resolution: float = 0.35,
     equidistant: bool = False,
     store_pos_as: str | None = None,
-) -> dict[Incomplete, Incomplete]: ...
+) -> dict[_Node, Array1D[np.float64]]: ...
 def multipartite_layout(
-    G, subset_key: str = "subset", align: str = "vertical", scale: float = 1, center=None, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    subset_key: str | Mapping[Any, Collection[_Node]] = "subset",  # layers can be "any" hashable
+    align: Literal["vertical", "horizontal"] = "vertical",
+    scale: float = 1,
+    center: _FloatArrayLike1D | None = None,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float64]]: ...
 def arf_layout(
-    G,
-    pos=None,
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]] | None = None,
     scaling: float = 1,
     a: float = 1.1,
     etol: float = 1e-06,
     dt: float = 0.001,
     max_iter: int = 1000,
     *,
-    seed: int | RandomState | None = None,
+    seed: Seed | None = None,
     store_pos_as: str | None = None,
-): ...
+) -> dict[_Node, Array1D[np.float32]]: ...
 @_dispatchable
 def forceatlas2_layout(
-    G,
-    pos=None,
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]] | None = None,
     *,
-    max_iter=100,
-    jitter_tolerance=1.0,
-    scaling_ratio=2.0,
+    max_iter: int = 100,
+    jitter_tolerance: float = 1.0,
+    scaling_ratio: float = 2.0,
     gravity: float = 1.0,
-    distributed_action=False,
-    strong_gravity=False,
-    node_mass=None,
-    node_size=None,
-    weight=None,
-    dissuade_hubs=False,
-    linlog=False,
-    seed: int | RandomState | None = None,
+    distributed_action: bool = False,
+    strong_gravity: bool = False,
+    node_mass: Mapping[_Node, float] | None = None,
+    node_size: Mapping[_Node, float] | None = None,
+    weight: str | None = None,
+    dissuade_hubs: bool = False,
+    linlog: bool = False,
+    seed: Seed | None = None,
     dim: int = 2,
     store_pos_as: str | None = None,
-) -> dict[Incomplete, Incomplete]: ...
-def rescale_layout(pos, scale: float = 1): ...
-def rescale_layout_dict(pos, scale: float = 1): ...
+) -> dict[_Node, Array1D[np.float32]]: ...
+def rescale_layout(pos: NDArray[np.number[Any]], scale: float = 1) -> Array2D[np.float64]: ...  # ignore the bit base
+def rescale_layout_dict(pos: Mapping[_Node, Collection[float]], scale: float = 1) -> dict[_Node, Array1D[np.float64]]: ...
 def bfs_layout(
-    G, start, *, align="vertical", scale=1, center=None, store_pos_as: str | None = None
-) -> dict[Incomplete, Incomplete]: ...
+    G: Graph[_Node],
+    start: _Node,
+    *,
+    align: Literal["vertical", "horizontal"] = "vertical",
+    scale: float = 1,
+    center: _FloatArrayLike1D | None = None,
+    store_pos_as: str | None = None,
+) -> dict[_Node, Array1D[np.float64]]: ...