basedpyright 1.31.5 → 1.31.6

package/dist/typeshed-fallback/stubs/networkx/networkx/drawing/nx_pylab.pyi

@@ -1,6 +1,17 @@
-from _typeshed import Incomplete
-from collections.abc import Collection, Iterable, Sequence
+from _typeshed import Incomplete, SupportsItems
+from collections.abc import Callable, Collection, Hashable, Iterable, Mapping, Sequence
+from typing import Any, Generic, Literal, TypedDict, TypeVar, overload, type_check_only
+from typing_extensions import TypeAlias, Unpack
 
+import numpy as np
+from matplotlib.axes import Axes  # type: ignore[import-not-found]
+from matplotlib.collections import LineCollection, PathCollection  # type: ignore[import-not-found]
+from matplotlib.colors import Colormap  # type: ignore[import-not-found]
+from matplotlib.patches import FancyArrowPatch  # type: ignore[import-not-found]
+from matplotlib.text import Text  # type: ignore[import-not-found]
+from matplotlib.typing import ColorType  # type: ignore[import-not-found]
+from networkx._typing import Array2D
+from networkx.classes.digraph import DiGraph
 from networkx.classes.graph import Graph, _Node
 
 __all__ = [
@@ -23,14 +34,87 @@ __all__ = [
     "draw_forceatlas2",
 ]
 
+_G = TypeVar("_G", bound=Graph[Any])
+
+# types from matplotlib
+_FontSize: TypeAlias = Literal["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large"] | float
+_FontWeight: TypeAlias = (
+    Literal[
+        "ultralight",
+        "light",
+        "normal",
+        "regular",
+        "book",
+        "medium",
+        "roman",
+        "semibold",
+        "demibold",
+        "demi",
+        "bold",
+        "heavy",
+        "extra bold",
+        "black",
+    ]
+    | int
+)
+_HAlign: TypeAlias = Literal["left", "center", "right"]
+_VAlign: TypeAlias = Literal["baseline", "bottom", "center", "center_baseline", "top"]
+
+@type_check_only
+class _DrawNetworkxKwds(TypedDict, Generic[_Node], total=False):
+    # draw nodes keywords; keep in sync with draw_networkx_nodes
+    node_color: ColorType | Collection[ColorType] | Collection[float]
+    cmap: str | Colormap | None
+    vmin: float | None
+    vmax: float | None
+    linewidths: float | Collection[float] | None
+    edgecolors: Literal["face", "none"] | ColorType | Collection[ColorType] | Collection[float] | None
+    margins: float | tuple[float, float] | None
+    # draw edges keywords; keep in sync with draw_networkx_edges
+    edgelist: Collection[_Node | Hashable] | None  # (u, v, k) for multigraphs and (u, v) for simple graphs
+    width: float | Collection[float]
+    edge_color: ColorType | Collection[ColorType]
+    style: str | Collection[str]
+    arrowstyle: str | Collection[str] | None
+    arrowsize: float | list[int] | list[float]
+    edge_cmap: Colormap | None
+    edge_vmin: float | None
+    edge_vmax: float | None
+    connectionstyle: str | Iterable[str]
+    min_source_margin: int | Collection[int]
+    min_target_margin: int | Collection[int]
+    # draw labels keywords; keep in sync with draw_networkx_labels
+    labels: Mapping[_Node, object] | None
+    font_size: _FontSize | Mapping[_Node, _FontSize]
+    font_color: ColorType | Mapping[_Node, Colormap]
+    font_family: str | Mapping[_Node, str]
+    font_weight: _FontWeight | Mapping[_Node, _FontWeight]
+    bbox: dict[str, Any] | None
+    horizontalalignment: _HAlign
+    verticalalignment: _VAlign
+    clip_on: bool
+    # common keywords
+    nodelist: Sequence[_Node] | None
+    node_size: float | Collection[float]
+    node_shape: str
+    alpha: float | Collection[float] | None
+    label: str | None
+    hide_ticks: bool
+
 def apply_matplotlib_colors(
-    G: Graph[_Node], src_attr: str, dest_attr: str, map, vmin: float | None = None, vmax: float | None = None, nodes: bool = True
+    G: Graph[_Node],
+    src_attr: str,
+    dest_attr: str,
+    map: str | Colormap,
+    vmin: float | None = None,
+    vmax: float | None = None,
+    nodes: bool = True,
 ) -> None: ...
 def display(
-    G: Graph[_Node],
-    canvas=None,
+    G: _G,
+    canvas: Axes | None = None,
     *,
-    pos=...,
+    pos: str | Callable[[_G], Mapping[_Node, Collection[float]]] = ...,
     node_visible: str | bool = ...,
     node_color: str = ...,
     node_size: str | float = ...,
@@ -41,7 +125,7 @@ def display(
     node_border_color: str = ...,
     edge_visible: str | bool = ...,
     edge_width: str | int = ...,
-    edge_color=...,
+    edge_color: str | ColorType = ...,
     edge_label: str = ...,
     edge_style: str = ...,
     edge_alpha: str | float = ...,
@@ -51,97 +135,220 @@ def display(
     edge_source_margin: str | int = ...,
     edge_target_margin: str | int = ...,
     hide_ticks: bool = True,
-): ...
-def draw(G: Graph[_Node], pos=None, ax=None, **kwds) -> None: ...
-def draw_networkx(G: Graph[_Node], pos=None, arrows=None, with_labels: bool = True, **kwds) -> None: ...
-def draw_networkx_nodes(
+) -> _G: ...
+def draw(
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]] | None = None,
+    ax: Axes | None = None,
+    *,
+    with_labels: bool = ...,  # default depends on whether a label argument is passed
+    **kwds: Unpack[_DrawNetworkxKwds[_Node]],
+) -> None: ...
+def draw_networkx(
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]] | None = None,
+    arrows: bool | None = None,
+    with_labels: bool = True,
+    *,
+    ax: Axes | None = None,
+    **kwds: Unpack[_DrawNetworkxKwds[_Node]],
+) -> None: ...
+def draw_networkx_nodes(  # keep in sync with _DrawNetworkxKwds above
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]],
+    nodelist: Collection[_Node] | None = None,
+    node_size: float | Collection[float] = 300,
+    node_color: ColorType | Collection[ColorType] | Collection[float] = "#1f78b4",
+    node_shape: str = "o",
+    alpha: float | Collection[float] | None = None,
+    cmap: str | Colormap | None = None,
+    vmin: float | None = None,
+    vmax: float | None = None,
+    ax: Axes | None = None,
+    linewidths: float | Collection[float] | None = None,
+    edgecolors: Literal["face", "none"] | ColorType | Collection[ColorType] | Collection[float] | None = None,
+    label: str | None = None,
+    margins: float | tuple[float, float] | None = None,
+    hide_ticks: bool = True,
+) -> PathCollection: ...
+@overload  # arrows=None -> LineCollection if G is undirected, list[FancyArrowPatch] if G is directed
+def draw_networkx_edges(  # keep in sync with _DrawNetworkxKwds above
     G: Graph[_Node],
-    pos,
-    nodelist: Collection[Incomplete] | None = None,
-    node_size: Incomplete | int = 300,
-    node_color: str | Sequence[str] = "#1f78b4",
+    pos: Mapping[_Node, Collection[float]],
+    edgelist: Collection[_Node | Hashable] | None = None,  # (u, v, k) for multigraphs and (u, v) for simple graphs
+    width: float | Collection[float] = 1.0,
+    edge_color: ColorType | Collection[ColorType] = "k",
+    style: str | Collection[str] = "solid",
+    alpha: float | Collection[float] | None = None,
+    arrowstyle: str | Collection[str] | None = None,
+    arrowsize: float | list[int] | list[float] = 10,  # documented as int, mpl accepts float
+    edge_cmap: Colormap | None = None,
+    edge_vmin: float | None = None,
+    edge_vmax: float | None = None,
+    ax: Axes | None = None,
+    arrows: None = None,
+    label: str | None = None,  # documented as str, mpl accepts any object as it calls str on it
+    node_size: float | Collection[float] = 300,
+    nodelist: Sequence[_Node] | None = None,
     node_shape: str = "o",
-    alpha=None,
-    cmap=None,
-    vmin=None,
-    vmax=None,
-    ax=None,
-    linewidths=None,
-    edgecolors=None,
-    label=None,
-    margins=None,
+    connectionstyle: str | Iterable[str] = "arc3",
+    min_source_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
+    min_target_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
     hide_ticks: bool = True,
-): ...
+) -> LineCollection | list[FancyArrowPatch]: ...
+@overload  # directed graph and arrows=None -> list[FancyArrowPatch]
+def draw_networkx_edges(
+    G: DiGraph[_Node],
+    pos: Mapping[_Node, Collection[float]],
+    edgelist: Collection[_Node | Hashable] | None = None,  # (u, v, k) for multigraphs and (u, v) for simple graphs
+    width: float | Collection[float] = 1.0,
+    edge_color: ColorType | Collection[ColorType] = "k",
+    style: str | Collection[str] = "solid",
+    alpha: float | Collection[float] | None = None,
+    arrowstyle: str | Collection[str] | None = None,
+    arrowsize: float | list[int] | list[float] = 10,  # documented as int, mpl accepts float
+    edge_cmap: Colormap | None = None,
+    edge_vmin: float | None = None,
+    edge_vmax: float | None = None,
+    ax: Axes | None = None,
+    arrows: None = None,
+    label: str | None = None,  # documented as str, mpl accepts any object as it calls str on it
+    node_size: float | Collection[float] = 300,
+    nodelist: Sequence[_Node] | None = None,
+    node_shape: str = "o",
+    connectionstyle: str | Iterable[str] = "arc3",
+    min_source_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
+    min_target_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
+    hide_ticks: bool = True,
+) -> list[FancyArrowPatch]: ...
+@overload  # arrows=True -> list[FancyArrowPatch]
 def draw_networkx_edges(
     G: Graph[_Node],
-    pos,
-    edgelist=None,
-    width: float = 1.0,
-    edge_color: str = "k",
-    style: str = "solid",
-    alpha=None,
-    arrowstyle=None,
-    arrowsize: int = 10,
-    edge_cmap=None,
-    edge_vmin=None,
-    edge_vmax=None,
-    ax=None,
-    arrows=None,
-    label=None,
-    node_size: Incomplete | int = 300,
-    nodelist: list[Incomplete] | None = None,
+    pos: Mapping[_Node, Collection[float]],
+    edgelist: Collection[_Node | Hashable] | None = None,  # (u, v, k) for multigraphs and (u, v) for simple graphs
+    width: float | Collection[float] = 1.0,
+    edge_color: ColorType | Collection[ColorType] = "k",
+    style: str | Collection[str] = "solid",
+    alpha: float | Collection[float] | None = None,
+    arrowstyle: str | Collection[str] | None = None,
+    arrowsize: float | list[int] | list[float] = 10,  # documented as int, mpl accepts float
+    edge_cmap: Colormap | None = None,
+    edge_vmin: float | None = None,
+    edge_vmax: float | None = None,
+    ax: Axes | None = None,
+    *,
+    arrows: Literal[True],
+    label: str | None = None,  # documented as str, mpl accepts any object as it calls str on it
+    node_size: float | Collection[float] = 300,
+    nodelist: Sequence[_Node] | None = None,
     node_shape: str = "o",
-    connectionstyle: str = "arc3",
-    min_source_margin: int = 0,
-    min_target_margin: int = 0,
+    connectionstyle: str | Iterable[str] = "arc3",
+    min_source_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
+    min_target_margin: int | Collection[int] = 0,  # documented as int, mpl accepts float
     hide_ticks: bool = True,
-): ...
-def draw_networkx_labels(
+) -> list[FancyArrowPatch]: ...
+@overload  # arrows=False -> LineCollection
+def draw_networkx_edges(
     G: Graph[_Node],
-    pos,
-    labels=None,
-    font_size: int = 12,
-    font_color: str = "k",
-    font_family: str = "sans-serif",
-    font_weight: str = "normal",
-    alpha=None,
-    bbox=None,
-    horizontalalignment: str = "center",
-    verticalalignment: str = "center",
-    ax=None,
+    pos: Mapping[_Node, Collection[float]],
+    edgelist: Collection[_Node | Hashable] | None = None,  # (u, v, k) for multigraphs and (u, v) for simple graphs
+    width: float | Collection[float] = 1.0,
+    edge_color: ColorType | Collection[ColorType] = "k",
+    style: str | Collection[str] = "solid",
+    alpha: float | Collection[float] | None = None,
+    *,
+    edge_cmap: Colormap | None = None,
+    edge_vmin: float | None = None,
+    edge_vmax: float | None = None,
+    ax: Axes | None = None,
+    arrows: Literal[False],
+    label: str | None = None,  # documented as str, mpl accepts any object as it calls str on it
+    node_size: float | Collection[float] = 300,
+    nodelist: Sequence[_Node] | None = None,
+    node_shape: str = "o",
+    hide_ticks: bool = True,
+) -> LineCollection: ...
+def draw_networkx_labels(  # keep in sync with _DrawNetworkxKwds above
+    G: Graph[_Node],
+    pos: Mapping[_Node, Collection[float]],
+    labels: Mapping[_Node, object] | None = None,  # labels are explicitly converted to str
+    font_size: _FontSize | Mapping[_Node, _FontSize] = 12,
+    font_color: ColorType | Mapping[_Node, Colormap] = "k",
+    font_family: str | Mapping[_Node, str] = "sans-serif",
+    font_weight: _FontWeight | Mapping[_Node, _FontWeight] = "normal",
+    alpha: float | Mapping[_Node, float] | None = None,
+    bbox: dict[str, Any] | None = None,  # Any comes from mpl
+    horizontalalignment: _HAlign = "center",  # doc is wrong, doesn't really accept array
+    verticalalignment: _VAlign = "center",  # doc is wrong, doesn't really accept array
+    ax: Axes | None = None,
     clip_on: bool = True,
     hide_ticks: bool = True,
-): ...
+) -> dict[_Node, Text]: ...
 def draw_networkx_edge_labels(
+    # TODO: find a way to have a covariant list for params annotated with `something | list[Incomplete]`
     G: Graph[_Node],
-    pos,
-    edge_labels=None,
-    label_pos: float = 0.5,
-    font_size: int = 10,
-    font_color: str = "k",
+    pos: Mapping[_Node, Collection[float]],
+    edge_labels: (
+        SupportsItems[
+            Collection[_Node | Hashable],  # (u, v, k) for multigraphs and (u, v) for simple graphs
+            object,  # labels are explicitly converted to str and nx internally passes non-str
+        ]
+        | None
+    ) = None,
+    label_pos: float | list[Incomplete] = 0.5,
+    font_size: _FontSize | list[Incomplete] = 10,
+    font_color: ColorType | list[Incomplete] = "k",
     font_family: str = "sans-serif",
-    font_weight: str = "normal",
-    alpha=None,
-    bbox=None,
-    horizontalalignment: str = "center",
-    verticalalignment: str = "center",
-    ax=None,
-    rotate: bool = True,
+    font_weight: _FontWeight | list[Incomplete] = "normal",
+    alpha: float | list[Incomplete] | None = None,
+    bbox: dict[str, Any] | None = None,  # Any comes from mpl
+    horizontalalignment: _HAlign | list[Incomplete] = "center",
+    verticalalignment: _VAlign | list[Incomplete] = "center",
+    ax: Axes | None = None,
+    rotate: bool | list[bool] = True,
     clip_on: bool = True,
-    node_size: int = 300,
-    nodelist: list[Incomplete] | None = None,
-    connectionstyle: str = "arc3",
+    node_size: float | Collection[float] = 300,
+    nodelist: Sequence[_Node] | None = None,
+    connectionstyle: str | Iterable[str] = "arc3",
     hide_ticks: bool = True,
-): ...
-def draw_bipartite(G: Graph[_Node], **kwargs): ...
-def draw_circular(G: Graph[_Node], **kwargs) -> None: ...
-def draw_kamada_kawai(G: Graph[_Node], **kwargs) -> None: ...
-def draw_random(G: Graph[_Node], **kwargs) -> None: ...
-def draw_spectral(G: Graph[_Node], **kwargs) -> None: ...
-def draw_spring(G: Graph[_Node], **kwargs) -> None: ...
-def draw_shell(G: Graph[_Node], nlist=None, **kwargs) -> None: ...
-def draw_planar(G: Graph[_Node], **kwargs) -> None: ...
-def draw_forceatlas2(G: Graph[_Node], **kwargs) -> None: ...
+) -> dict[tuple[_Node, _Node] | tuple[_Node, _Node, Any], Text]: ...  # Any is for multigraph key
+def draw_bipartite(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_circular(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_kamada_kawai(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_random(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_spectral(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_spring(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_shell(
+    G: Graph[_Node],
+    nlist: Collection[Collection[_Node]] | None = None,
+    *,
+    ax: Axes | None = None,
+    with_labels: bool = ...,
+    **kwargs: Unpack[_DrawNetworkxKwds[_Node]],
+) -> None: ...
+def draw_planar(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
+def draw_forceatlas2(
+    G: Graph[_Node], *, ax: Axes | None = None, with_labels: bool = ..., **kwargs: Unpack[_DrawNetworkxKwds[_Node]]
+) -> None: ...
 def apply_alpha(
-    colors, alpha: float | Iterable[float], elem_list, cmap=None, vmin: float | None = None, vmax: float | None = None
-): ...
+    colors: ColorType | Collection[ColorType] | Collection[float],
+    alpha: float | Collection[float],
+    elem_list: Collection[object],  # nx objects (nodes, edges, labels) but its content is not used!
+    cmap: str | Colormap | None = None,
+    vmin: float | None = None,
+    vmax: float | None = None,
+) -> Array2D[np.float64]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/readwrite/gexf.pyi

@@ -1,5 +1,6 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
+from typing import Final, Literal
 
 from networkx.utils.backends import _dispatchable
 
@@ -17,7 +18,7 @@ class GEXF:
     xml_type: Incomplete
     python_type: Incomplete
     def construct_types(self) -> None: ...
-    convert_bool: Incomplete
+    convert_bool: Final[dict[Literal["true", "false", "True", "False", "0", 0, "1", 1], bool]]
     NS_GEXF: Incomplete
     NS_VIZ: Incomplete
     NS_XSI: Incomplete

package/dist/typeshed-fallback/stubs/networkx/networkx/readwrite/graphml.pyi

@@ -1,6 +1,6 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
-from typing import Final
+from typing import Final, Literal
 
 from networkx.utils.backends import _dispatchable
 
@@ -49,7 +49,7 @@ class GraphML:
     xml_type: Incomplete
     python_type: Incomplete
     def construct_types(self) -> None: ...
-    convert_bool: Incomplete
+    convert_bool: Final[dict[Literal["true", "false", "0", 0, "1", 1], bool]]
     def get_xml_type(self, key): ...
 
 class GraphMLWriter(GraphML):

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/heaps.pyi

@@ -4,6 +4,7 @@ __all__ = ["MinHeap", "PairingHeap", "BinaryHeap"]
 
 class MinHeap:
     class _Item:
+        __slots__ = ("key", "value")
         key: Incomplete
         value: Incomplete
         def __init__(self, key, value) -> None: ...
@@ -20,6 +21,7 @@ class MinHeap:
 
 class PairingHeap(MinHeap):
     class _Node(MinHeap._Item):
+        __slots__ = ("left", "next", "prev", "parent")
         left: Incomplete
         next: Incomplete
         prev: Incomplete

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/mapped_queue.pyi

@@ -4,6 +4,7 @@ from collections.abc import Iterator
 __all__ = ["MappedQueue"]
 
 class _HeapElement:
+    __slots__ = ["priority", "element", "_hash"]
     priority: Incomplete
     element: Incomplete
     def __init__(self, priority, element) -> None: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/misc.pyi

@@ -1,6 +1,7 @@
 import random
+import sys
 from types import ModuleType
-from typing_extensions import TypeAlias
+from typing_extensions import Self, TypeAlias
 
 import numpy
 
@@ -36,6 +37,10 @@ def create_random_state(random_state=None): ...
 
 class PythonRandomViaNumpyBits(random.Random):
     def __init__(self, rng: numpy.random.Generator | None = None) -> None: ...
+    if sys.version_info < (3, 10):
+        # this is a workaround for pyright correctly flagging an inconsistent inherited constructor, see #14624
+        def __new__(cls, rng: numpy.random.Generator | None = None) -> Self: ...
+
     def getrandbits(self, k: int) -> int: ...
 
 class PythonRandomInterface:

package/dist/typeshed-fallback/stubs/oauthlib/oauthlib/oauth2/rfc6749/endpoints/token.pyi

@@ -23,7 +23,7 @@ class TokenEndpoint(BaseEndpoint):
         self,
         uri: str,
         http_method: _HTTPMethod = "POST",
-        body: str | None = None,
+        body: str | dict[str, str] | list[tuple[str, str]] | None = None,
         headers: dict[str, str] | None = None,
         credentials=None,
         grant_type_for_scope=None,

package/dist/typeshed-fallback/stubs/oauthlib/oauthlib/oauth2/rfc6749/tokens.pyi

@@ -46,11 +46,13 @@ def signed_token_generator(private_pem: str, **kwargs) -> Callable[[Request], st
 def get_token_from_header(request: Request) -> str | None: ...
 
 class TokenBase:
+    __slots__ = ()
     def __call__(self, request: Request, refresh_token: bool = False) -> None: ...
     def validate_request(self, request: Request) -> bool: ...
     def estimate_type(self, request: Request) -> int: ...
 
 class BearerToken(TokenBase):
+    __slots__ = ("request_validator", "token_generator", "refresh_token_generator", "expires_in")
     request_validator: RequestValidator | None
     token_generator: Callable[[Request], str]
     refresh_token_generator: Callable[[Request], str]

package/dist/typeshed-fallback/stubs/oauthlib/oauthlib/openid/connect/core/tokens.pyi

@@ -6,6 +6,7 @@ from oauthlib.oauth2.rfc6749.tokens import TokenBase as TokenBase
 from .request_validator import RequestValidator
 
 class JWTToken(TokenBase):
+    __slots__ = ("request_validator", "token_generator", "refresh_token_generator", "expires_in")
     request_validator: RequestValidator
     token_generator: Callable[[Request], str] | Callable[[Request, bool], str]
     refresh_token_generator: Callable[[Request], str] | Callable[[Request, bool], str]

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/cell/cell.pyi

@@ -36,6 +36,7 @@ def get_type(t: type, value: object) -> Literal["n", "s", "d", "f"] | None: ...
 def get_time_format(t: _TimeTypes) -> str: ...
 
 class Cell(StyleableObject):
+    __slots__ = ("row", "column", "_value", "data_type", "parent", "_hyperlink", "_comment")
     row: int
     column: int
     data_type: str
@@ -82,6 +83,7 @@ class Cell(StyleableObject):
     def comment(self, value: Comment | None) -> None: ...
 
 class MergedCell(StyleableObject):
+    __slots__ = ("row", "column")
     data_type: str
     comment: Comment | None
     hyperlink: Hyperlink | None

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/cell/read_only.pyi

@@ -12,6 +12,7 @@ from openpyxl.workbook.child import _WorkbookChild
 from openpyxl.worksheet._read_only import ReadOnlyWorksheet
 
 class ReadOnlyCell:
+    __slots__ = ("parent", "row", "column", "_value", "data_type", "_style_id")
     parent: _WorkbookChild | ReadOnlyWorksheet
     row: Incomplete
     column: Incomplete
@@ -58,6 +59,7 @@ class ReadOnlyCell:
     def value(self, value: None) -> None: ...
 
 class EmptyCell:
+    __slots__ = ()
     value: Incomplete
     is_date: bool
     font: Incomplete

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/descriptors/sequence.pyi

@@ -38,7 +38,7 @@ class Sequence(Descriptor[_ContainerT]):
 
 # `_T` is the type of the elements in the sequence.
 class UniqueSequence(Sequence[set[_T]]):
-    seq_types: tuple[type[list[_T]], type[tuple[_T, ...]], type[set[_T]]]
+    seq_types: tuple[type, ...]  # defaults to `list`, `tuple`, `set`
     container: type[set[_T]]
 
 # See `Sequence` for the meaning of `_ContainerT`.

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/formula/tokenizer.pyi

@@ -30,6 +30,7 @@ class Tokenizer:
     def render(self): ...
 
 class Token:
+    __slots__ = ["value", "type", "subtype"]
     LITERAL: Final = "LITERAL"
     OPERAND: Final = "OPERAND"
     FUNC: Final = "FUNC"

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/pivot/table.pyi

@@ -417,7 +417,7 @@ class ConditionalFormatList(Serialisable):
     tagname: ClassVar[str]
     conditionalFormat: Incomplete
     __attrs__: ClassVar[tuple[str, ...]]
-    def __init__(self, conditionalFormat=..., count: Incomplete | None = ...) -> None: ...
+    def __init__(self, conditionalFormat=(), count=None) -> None: ...
     def by_priority(self): ...
     @property
     def count(self) -> int: ...

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/styles/cell_style.pyi

@@ -19,6 +19,7 @@ class ArrayDescriptor(Generic[_T]):
     def __set__(self, instance: MutableSequence[_T], value: _T) -> None: ...
 
 class StyleArray(array[int]):
+    __slots__ = ()
     tagname: ClassVar[str]
     fontId: ArrayDescriptor[int]
     fillId: ArrayDescriptor[int]
@@ -30,7 +31,6 @@ class StyleArray(array[int]):
     quotePrefix: ArrayDescriptor[int]
     xfId: ArrayDescriptor[int]
     def __new__(cls, args: bytes | bytearray | Iterable[int] = [0, 0, 0, 0, 0, 0, 0, 0, 0]) -> Self: ...
-    def __init__(self, args: bytes | bytearray | Iterable[int] = [0, 0, 0, 0, 0, 0, 0, 0, 0]) -> None: ...
     def __hash__(self) -> int: ...  # type: ignore[override]
     def __copy__(self) -> StyleArray: ...
     def __deepcopy__(self, memo: Unused) -> StyleArray: ...

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/styles/proxy.pyi

@@ -1,6 +1,7 @@
 from typing_extensions import deprecated
 
 class StyleProxy:
+    __slots__ = "__target"
     def __init__(self, target) -> None: ...
     def __getattr__(self, attr: str): ...
     def __setattr__(self, attr: str, value) -> None: ...

package/dist/typeshed-fallback/stubs/openpyxl/openpyxl/styles/styleable.pyi

@@ -34,6 +34,7 @@ class StyleArrayDescriptor:
     def __get__(self, instance: StyleableObject, cls: Unused) -> bool: ...
 
 class StyleableObject:
+    __slots__ = ("parent", "_style")
     font: StyleDescriptor
     fill: StyleDescriptor
     border: StyleDescriptor

package/dist/typeshed-fallback/stubs/paramiko/paramiko/packet.pyi

@@ -57,7 +57,7 @@ class Packetizer:
     def get_mac_size_in(self) -> int: ...
     def get_mac_size_out(self) -> int: ...
     def need_rekey(self) -> bool: ...
-    def set_keepalive(self, interval: int, callback: Callable[[], object]) -> None: ...
+    def set_keepalive(self, interval: float, callback: Callable[[], object]) -> None: ...
     def read_timer(self) -> None: ...
     def start_handshake(self, timeout: float) -> None: ...
     def handshake_timed_out(self) -> bool: ...

package/dist/typeshed-fallback/stubs/paramiko/paramiko/transport.pyi

@@ -136,7 +136,7 @@ class Transport(Thread, ClosingContextManager):
     def open_sftp_client(self) -> SFTPClient | None: ...
     def send_ignore(self, byte_count: int | None = None) -> None: ...
     def renegotiate_keys(self) -> None: ...
-    def set_keepalive(self, interval: int) -> None: ...
+    def set_keepalive(self, interval: float) -> None: ...
     def global_request(self, kind: str, data: Iterable[Any] | None = None, wait: bool = True) -> Message | None: ...
     def accept(self, timeout: float | None = None) -> Channel | None: ...
     def connect(
@@ -175,6 +175,7 @@ class Transport(Thread, ClosingContextManager):
     def run(self) -> None: ...
 
 class SecurityOptions:
+    __slots__ = "_transport"
     def __init__(self, transport: Transport) -> None: ...
     @property
     def ciphers(self) -> Sequence[str]: ...