basedpyright 1.29.2 → 1.29.3

package/dist/typeshed-fallback/stubs/jsonschema/METADATA.toml

@@ -1,4 +1,4 @@
-version = "4.23.*"
+version = "4.24.*"
 upstream_repository = "https://github.com/python-jsonschema/jsonschema"
 requires = ["referencing"]
 partial_stub = true

package/dist/typeshed-fallback/stubs/jsonschema/jsonschema/_utils.pyi

@@ -1,4 +1,4 @@
-from _typeshed import Incomplete, SupportsKeysAndGetItem
+from _typeshed import Incomplete, SupportsKeysAndGetItem, SupportsNext
 from collections.abc import Generator, Iterable, Iterator, Mapping, MutableMapping, Sized
 
 class URIDict(MutableMapping[str, str]):
@@ -24,3 +24,4 @@ def unbool(element, true=..., false=...): ...
 def uniq(container) -> bool: ...
 def find_evaluated_item_indexes_by_schema(validator, instance, schema) -> list[Incomplete]: ...
 def find_evaluated_property_keys_by_schema(validator, instance, schema) -> list[Incomplete]: ...
+def is_valid(errs_it: SupportsNext[object]) -> bool: ...

package/dist/typeshed-fallback/stubs/jsonschema/jsonschema/validators.pyi

@@ -1,8 +1,8 @@
 from _typeshed import Incomplete, SupportsKeysAndGetItem
 from collections.abc import Callable, Generator, Iterable, Iterator, Mapping
 from contextlib import contextmanager
-from typing import Any, ClassVar
-from typing_extensions import TypeAlias
+from typing import Any, ClassVar, overload
+from typing_extensions import TypeAlias, deprecated
 
 from referencing.jsonschema import Schema, SchemaRegistry
 from referencing.typing import URI
@@ -11,6 +11,7 @@ from ._format import FormatChecker
 from ._types import TypeChecker
 from ._utils import Unset, URIDict
 from .exceptions import ValidationError
+from .protocols import Validator
 
 # these type aliases do not exist at runtime, they're only defined here in the stub
 _JsonObject: TypeAlias = Mapping[str, Any]
@@ -40,15 +41,27 @@ class _Validator:
     @classmethod
     def check_schema(cls, schema: Schema, format_checker: FormatChecker | Unset = ...) -> None: ...
     @property
+    @deprecated(
+        "Accessing resolver() is deprecated as of v4.18.0, "
+        "in favor of the https://github.com/python-jsonschema/referencing library."
+    )
     def resolver(self): ...
     def evolve(self, **changes) -> _Validator: ...
-    def iter_errors(self, instance, _schema: Schema | None = ...) -> Generator[Incomplete, None, None]: ...
+    @overload
+    def iter_errors(self, instance) -> Generator[Incomplete]: ...
+    @overload
+    @deprecated("Passing a schema to Validator.iter_errors is deprecated and will be removed in a future release.")
+    def iter_errors(self, instance, _schema: Schema | None) -> Generator[Incomplete]: ...
     def descend(
         self, instance, schema: Schema, path: Incomplete | None = ..., schema_path: Incomplete | None = ..., resolver=None
     ) -> Generator[Incomplete, None, None]: ...
     def validate(self, *args, **kwargs) -> None: ...
-    def is_type(self, instance, type): ...
-    def is_valid(self, instance, _schema: Schema | None = ...) -> bool: ...
+    def is_type(self, instance, type) -> bool: ...
+    @overload
+    def is_valid(self, instance) -> bool: ...
+    @overload
+    @deprecated("Passing a schema to Validator.is_valid is deprecated and will be removed in a future release.")
+    def is_valid(self, instance, _schema: Schema | None) -> bool: ...
 
 def validates(version: str) -> Callable[..., Incomplete]: ...
 def create(
@@ -94,15 +107,16 @@ class RefResolver:
     @property
     def resolution_scope(self): ...
     @property
-    def base_uri(self): ...
+    def base_uri(self) -> str: ...
     @contextmanager
+    @deprecated("jsonschema.RefResolver.in_scope is deprecated and will be removed in a future release.")
     def in_scope(self, scope) -> Generator[None]: ...
     @contextmanager
-    def resolving(self, ref) -> Generator[Incomplete, None, None]: ...
-    def resolve(self, ref): ...
-    def resolve_from_url(self, url): ...
-    def resolve_fragment(self, document, fragment): ...
-    def resolve_remote(self, uri): ...
+    def resolving(self, ref: str) -> Generator[Incomplete]: ...
+    def resolve(self, ref: str) -> tuple[str, Incomplete]: ...
+    def resolve_from_url(self, url: str): ...
+    def resolve_fragment(self, document, fragment: str): ...
+    def resolve_remote(self, uri: str): ...
 
 def validate(instance: object, schema: Schema, cls: type[_Validator] | None = None, *args: Any, **kwargs: Any) -> None: ...
-def validator_for(schema: Schema | bool, default=...): ...
+def validator_for(schema: Schema | bool, default: type[Validator] | Unset = ...) -> type[Validator]: ...

package/dist/typeshed-fallback/stubs/networkx/METADATA.toml

@@ -1,4 +1,4 @@
-version = "3.4.2"
+version = "3.5"
 upstream_repository = "https://github.com/networkx/networkx"
 # requires a version of numpy with a `py.typed` file
 requires = ["numpy>=1.20"]

package/dist/typeshed-fallback/stubs/networkx/networkx/__init__.pyi

@@ -1,3 +1,5 @@
+from typing import Final
+
 from networkx.algorithms import *
 from networkx.classes import *
 from networkx.classes import filters as filters
@@ -24,3 +26,5 @@ from . import (
     relabel as relabel,
     utils as utils,
 )
+
+__version__: Final[str]

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/__init__.pyi

@@ -118,6 +118,7 @@ from networkx.algorithms.structuralholes import *
 from networkx.algorithms.summarization import *
 from networkx.algorithms.swap import *
 from networkx.algorithms.time_dependent import *
+from networkx.algorithms.tournament import is_tournament as is_tournament
 from networkx.algorithms.traversal import *
 from networkx.algorithms.tree.branchings import (
     ArborescenceIterator as ArborescenceIterator,

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/approximation/__init__.pyi

@@ -1,6 +1,7 @@
 from networkx.algorithms.approximation.clique import *
 from networkx.algorithms.approximation.clustering_coefficient import *
 from networkx.algorithms.approximation.connectivity import *
+from networkx.algorithms.approximation.density import *
 from networkx.algorithms.approximation.distance_measures import *
 from networkx.algorithms.approximation.dominating_set import *
 from networkx.algorithms.approximation.kcomponents import *

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/approximation/density.pyi

@@ -0,0 +1,15 @@
+from collections.abc import Callable, Hashable
+from typing import Literal
+from typing_extensions import TypeAlias
+
+from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
+
+_Algorithm: TypeAlias = Literal["greedy++", "fista"]
+
+__all__ = ["densest_subgraph"]
+
+ALGORITHMS: dict[_Algorithm, Callable[[Graph[Hashable], int], tuple[float, set[int]]]]
+
+@_dispatchable
+def densest_subgraph(G: Graph[_Node], iterations: int = 1, *, method: _Algorithm = "fista") -> tuple[float, set[int]]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/approximation/traveling_salesman.pyi

@@ -1,5 +1,6 @@
-from _typeshed import Incomplete
-from collections.abc import Callable
+from _typeshed import Incomplete, SupportsLenAndGetItem
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar
 
 from networkx.classes.digraph import DiGraph
 from networkx.classes.graph import Graph, _Node
@@ -15,6 +16,10 @@ __all__ = [
     "threshold_accepting_tsp",
 ]
 
+_SupportsLenAndGetItemT = TypeVar("_SupportsLenAndGetItemT", bound=SupportsLenAndGetItem[Any])
+
+def swap_two_nodes(soln: _SupportsLenAndGetItemT, seed) -> _SupportsLenAndGetItemT: ...
+def move_one_node(soln: _SupportsLenAndGetItemT, seed) -> _SupportsLenAndGetItemT: ...
 @_dispatchable
 def christofides(G: Graph[_Node], weight: str | None = "weight", tree: Graph[_Node] | None = None): ...
 @_dispatchable
@@ -31,6 +36,10 @@ def asadpour_atsp(
     G: DiGraph[_Node], weight: str | None = "weight", seed: int | RandomState | None = None, source: str | None = None
 ): ...
 @_dispatchable
+def held_karp_ascent(G: Graph[_Node], weight="weight"): ...
+@_dispatchable
+def spanning_tree_distribution(G: Graph[_Node], z: Mapping[Incomplete, Incomplete]) -> dict[Incomplete, Incomplete]: ...
+@_dispatchable
 def greedy_tsp(G: Graph[_Node], weight: str | None = "weight", source=None): ...
 @_dispatchable
 def simulated_annealing_tsp(

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/approximation/treewidth.pyi

@@ -15,3 +15,7 @@ class MinDegreeHeuristic:
 
     def __init__(self, graph) -> None: ...
     def best_node(self, graph): ...
+
+def min_fill_in_heuristic(graph_dict) -> Incomplete | None: ...
+@_dispatchable
+def treewidth_decomp(G: Graph[_Node], heuristic=...) -> tuple[int, Graph[_Node]]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/asteroidal.pyi

@@ -1,3 +1,5 @@
+from _typeshed import Incomplete
+
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
@@ -7,3 +9,5 @@ __all__ = ["is_at_free", "find_asteroidal_triple"]
 def find_asteroidal_triple(G: Graph[_Node]): ...
 @_dispatchable
 def is_at_free(G: Graph[_Node]) -> bool: ...
+@_dispatchable
+def create_component_structure(G: Graph[_Node]) -> dict[Incomplete, Incomplete]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/bipartite/__init__.pyi

@@ -5,6 +5,7 @@ from networkx.algorithms.bipartite.covering import *
 from networkx.algorithms.bipartite.edgelist import *
 from networkx.algorithms.bipartite.extendability import *
 from networkx.algorithms.bipartite.generators import *
+from networkx.algorithms.bipartite.link_analysis import *
 from networkx.algorithms.bipartite.matching import *
 from networkx.algorithms.bipartite.matrix import *
 from networkx.algorithms.bipartite.projection import *

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/bipartite/cluster.pyi

@@ -1,11 +1,17 @@
 from _typeshed import Incomplete
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 __all__ = ["clustering", "average_clustering", "latapy_clustering", "robins_alexander_clustering"]
 
+def cc_dot(nu, nv) -> float: ...
+def cc_max(nu, nv) -> float: ...
+def cc_min(nu, nv) -> float: ...
+
+modes: dict[str, Callable[[Incomplete, Incomplete], float]]
+
 @_dispatchable
 def latapy_clustering(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None, mode: str = "dot"): ...
 

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/bipartite/link_analysis.pyi

@@ -0,0 +1,20 @@
+from collections.abc import Iterable
+
+from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
+
+__all__ = ["birank"]
+
+@_dispatchable
+def birank(
+    G: Graph[_Node],
+    nodes: Iterable[_Node],
+    *,
+    alpha: float | None = None,
+    beta: float | None = None,
+    top_personalization: dict[str, int] | None = None,
+    bottom_personalization: dict[str, int] | None = None,
+    max_iter: int = 100,
+    tol: float = 1.0e-6,
+    weight: str | None = "weight",
+) -> dict[_Node, float]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/clique.pyi

@@ -37,3 +37,15 @@ def node_clique_number(G: Graph[_Node], nodes=None, cliques: Iterable[Incomplete
 def number_of_cliques(G, nodes=None, cliques=None) -> int | dict[Incomplete, Incomplete]: ...
 @_dispatchable
 def max_weight_clique(G, weight="weight") -> tuple[Incomplete, Incomplete]: ...
+
+class MaxWeightClique:
+    G: Graph[Incomplete]
+    incumbent_nodes: list[Incomplete]
+    incumbent_weight: int
+    node_weights: dict[Incomplete, int]
+    def __init__(self, G: Graph[_Node], weight): ...
+    def update_incumbent_if_improved(self, C, C_weight): ...
+    def greedily_find_independent_set(self, P): ...
+    def find_branching_nodes(self, P, target): ...
+    def expand(self, C, C_weight, P): ...
+    def find_max_weight_clique(self): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/coloring/equitable_coloring.pyi

@@ -11,5 +11,13 @@ __all__ = ["equitable_color"]
 def is_coloring(G: Graph[_Node], coloring: SupportsGetItem[Incomplete, Incomplete]) -> bool: ...
 @_dispatchable
 def is_equitable(G: Graph[_Node], coloring: Mapping[Incomplete, Incomplete], num_colors: SupportsIndex | None = None) -> bool: ...
+def make_C_from_F(F): ...
+def make_N_from_L_C(L, C): ...
+def make_H_from_C_N(C, N): ...
+def change_color(u, X, Y, N, H, F, C, L): ...
+def move_witnesses(src_color, dst_color, N, H, F, C, T_cal, L): ...
+@_dispatchable
+def pad_graph(G: Graph[_Node], num_colors): ...
+def procedure_P(V_minus, V_plus, N, H, F, C, L, excluded_colors=None): ...
 @_dispatchable
 def equitable_color(G: Graph[_Node], num_colors): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/coloring/greedy_coloring.pyi

@@ -1,5 +1,6 @@
 from _typeshed import Incomplete
-from collections.abc import Generator
+from collections.abc import Callable, Generator
+from typing import Final
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -32,5 +33,8 @@ def strategy_connected_sequential_dfs(G, colors): ...
 def strategy_connected_sequential(G, colors, traversal: str = "bfs") -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def strategy_saturation_largest_first(G, colors) -> Generator[Incomplete, None, Incomplete]: ...
+
+STRATEGIES: Final[dict[str, Callable[..., Incomplete]]]
+
 @_dispatchable
 def greedy_color(G: Graph[_Node], strategy="largest_first", interchange: bool = False): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/__init__.pyi

@@ -5,6 +5,8 @@ from networkx.algorithms.community.divisive import *
 from networkx.algorithms.community.kclique import *
 from networkx.algorithms.community.kernighan_lin import *
 from networkx.algorithms.community.label_propagation import *
+from networkx.algorithms.community.leiden import *
+from networkx.algorithms.community.local import *
 from networkx.algorithms.community.louvain import *
 from networkx.algorithms.community.lukes import *
 from networkx.algorithms.community.modularity_max import *

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/divisive.pyi

@@ -1,13 +1,13 @@
 from _typeshed import Incomplete
 
-import networkx as nx
 from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
 
 __all__ = ["edge_betweenness_partition", "edge_current_flow_betweenness_partition"]
 
-@nx._dispatchable
+@_dispatchable
 def edge_betweenness_partition(G: Graph[_Node], number_of_sets: int, *, weight: str | None = None) -> list[Incomplete]: ...
-@nx._dispatchable
+@_dispatchable
 def edge_current_flow_betweenness_partition(
     G: Graph[_Node], number_of_sets: int, *, weight: str | None = None
 ) -> list[Incomplete]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/leiden.pyi

@@ -0,0 +1,18 @@
+from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
+
+__all__ = ["leiden_communities", "leiden_partitions"]
+
+@_dispatchable
+def leiden_communities(
+    G: Graph[_Node],
+    weight: str | None = "weight",
+    resolution: float = 1,
+    max_level: int | None = None,
+    seed: int | RandomState | None = None,
+): ...
+@_dispatchable
+def leiden_partitions(
+    G: Graph[_Node], weight: str | None = "weight", resolution: float = 1, seed: int | RandomState | None = None
+): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/local.pyi

@@ -0,0 +1,15 @@
+from collections.abc import Callable, Hashable
+from typing import Literal
+from typing_extensions import TypeAlias
+
+from networkx.classes.graph import Graph, _Node
+
+__all__ = ["greedy_source_expansion"]
+
+_Algorithm: TypeAlias = Literal["clauset"]
+
+ALGORITHMS: dict[_Algorithm, Callable[[Graph[Hashable], Hashable, int | None], set[Hashable]]]
+
+def greedy_source_expansion(
+    G: Graph[_Node], *, source: _Node, cutoff: int | None = None, method: _Algorithm = "clauset"
+) -> set[_Node | None]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/lukes.pyi

@@ -1,7 +1,16 @@
+from typing import Final
+
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 __all__ = ["lukes_partitioning"]
 
+D_EDGE_W: Final = "weight"
+D_EDGE_VALUE: Final[float]
+D_NODE_W: Final = "weight"
+D_NODE_VALUE: Final = 1
+PKEY: Final = "partitions"
+CLUSTER_EVAL_CACHE_SIZE: Final = 2048
+
 @_dispatchable
 def lukes_partitioning(G: Graph[_Node], max_size: int, node_weight=None, edge_weight=None): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/community/quality.pyi

@@ -1,12 +1,21 @@
 from networkx.classes.graph import Graph, _Node
 from networkx.exception import NetworkXError
 from networkx.utils.backends import _dispatchable
+from networkx.utils.decorators import argmap
 
 __all__ = ["modularity", "partition_quality"]
 
 class NotAPartition(NetworkXError):
     def __init__(self, G, collection) -> None: ...
 
+require_partition: argmap
+
+@_dispatchable
+def intra_community_edges(G: Graph[_Node], partition): ...
+@_dispatchable
+def inter_community_edges(G: Graph[_Node], partition): ...
+@_dispatchable
+def inter_community_non_edges(G: Graph[_Node], partition): ...
 @_dispatchable
 def modularity(G: Graph[_Node], communities, weight: str | None = "weight", resolution: float = 1): ...
 @_dispatchable

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/connectivity/edge_augmentation.pyi

@@ -1,5 +1,6 @@
-from _typeshed import SupportsGetItem
+from _typeshed import Incomplete, SupportsGetItem
 from collections.abc import Generator
+from typing import NamedTuple
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -18,3 +19,29 @@ def k_edge_augmentation(
     weight: str | None = None,
     partial: bool = False,
 ) -> Generator[tuple[_Node, _Node], None, None]: ...
+@_dispatchable
+def partial_k_edge_augmentation(G: Graph[_Node], k, avail, weight: str | None = None): ...
+@_dispatchable
+def one_edge_augmentation(G: Graph[_Node], avail=None, weight: str | None = None, partial: bool = False): ...
+@_dispatchable
+def bridge_augmentation(G: Graph[_Node], avail=None, weight: str | None = None): ...
+
+class MetaEdge(NamedTuple):
+    meta_uv: Incomplete
+    uv: Incomplete
+    w: Incomplete
+
+@_dispatchable
+def unconstrained_one_edge_augmentation(G: Graph[_Node]): ...
+@_dispatchable
+def weighted_one_edge_augmentation(G: Graph[_Node], avail, weight: str | None = None, partial: bool = False): ...
+@_dispatchable
+def unconstrained_bridge_augmentation(G: Graph[_Node]): ...
+@_dispatchable
+def weighted_bridge_augmentation(G: Graph[_Node], avail, weight: str | None = None): ...
+@_dispatchable
+def collapse(G: Graph[_Node], grouped_nodes): ...
+@_dispatchable
+def complement_edges(G: Graph[_Node]): ...
+@_dispatchable
+def greedy_k_edge_augmentation(G: Graph[_Node], k, avail=None, weight: str | None = None, seed=None): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/connectivity/edge_kcomponents.pyi

@@ -21,3 +21,6 @@ class EdgeComponentAuxGraph:
     def construct(cls, G): ...
     def k_edge_components(self, k: int) -> Generator[Incomplete, Incomplete, None]: ...
     def k_edge_subgraphs(self, k: int) -> Generator[Incomplete, Incomplete, None]: ...
+
+@_dispatchable
+def general_k_edge_subgraphs(G: Graph[_Node], k): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/connectivity/kcomponents.pyi

@@ -10,3 +10,4 @@ default_flow_func = edmonds_karp
 
 @_dispatchable
 def k_components(G: Graph[_Node], flow_func: Callable[..., Incomplete] | None = None): ...
+def build_k_number_dict(kcomps) -> dict[Incomplete, Incomplete]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/d_separation.pyi

@@ -4,17 +4,13 @@ from networkx.classes.digraph import DiGraph
 from networkx.classes.graph import _Node
 from networkx.utils.backends import _dispatchable
 
-__all__ = ["is_d_separator", "is_minimal_d_separator", "find_minimal_d_separator", "d_separated", "minimal_d_separator"]
+__all__ = ["is_d_separator", "is_minimal_d_separator", "find_minimal_d_separator"]
 
 @_dispatchable
 def is_d_separator(G: DiGraph[_Node], x: _Node | set[_Node], y: _Node | set[_Node], z: _Node | set[_Node]) -> bool: ...
 @_dispatchable
 def find_minimal_d_separator(G, x, y, *, included=None, restricted=None) -> set[Incomplete] | None: ...
 @_dispatchable
-def d_separated(G, x, y, z): ...
-@_dispatchable
-def minimal_d_separator(G, u, v): ...
-@_dispatchable
 def is_minimal_d_separator(
     G: DiGraph[_Node],
     x: _Node | set[_Node],

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/distance_measures.pyi

@@ -1,6 +1,11 @@
+from collections.abc import Callable
+from typing_extensions import TypeAlias
+
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
+_WeightFunction: TypeAlias = Callable[..., int]
+
 __all__ = [
     "eccentricity",
     "diameter",
@@ -15,22 +20,22 @@ __all__ = [
 ]
 
 @_dispatchable
-def eccentricity(G: Graph[_Node], v: _Node | None = None, sp=None, weight: str | None = None): ...
+def eccentricity(G: Graph[_Node], v: _Node | None = None, sp=None, weight: str | _WeightFunction | None = None): ...
 @_dispatchable
-def diameter(G: Graph[_Node], e=None, usebounds=False, weight: str | None = None): ...
+def diameter(G: Graph[_Node], e=None, usebounds: bool = False, weight: str | _WeightFunction | None = None): ...
 @_dispatchable
-def harmonic_diameter(G, sp=None) -> float: ...
+def harmonic_diameter(G, sp=None, *, weight: str | _WeightFunction | None = None) -> float: ...
 @_dispatchable
-def periphery(G: Graph[_Node], e=None, usebounds=False, weight: str | None = None): ...
+def periphery(G: Graph[_Node], e=None, usebounds: bool = False, weight: str | _WeightFunction | None = None): ...
 @_dispatchable
-def radius(G: Graph[_Node], e=None, usebounds=False, weight: str | None = None): ...
+def radius(G: Graph[_Node], e=None, usebounds: bool = False, weight: str | _WeightFunction | None = None): ...
 @_dispatchable
-def center(G: Graph[_Node], e=None, usebounds=False, weight: str | None = None): ...
+def center(G: Graph[_Node], e=None, usebounds: bool = False, weight: str | _WeightFunction | None = None): ...
 @_dispatchable
-def barycenter(G, weight: str | None = None, attr=None, sp=None): ...
+def barycenter(G, weight: str | _WeightFunction | None = None, attr=None, sp=None): ...
 @_dispatchable
 def resistance_distance(G: Graph[_Node], nodeA=None, nodeB=None, weight: str | None = None, invert_weight: bool = True): ...
 @_dispatchable
-def effective_graph_resistance(G, weight=None, invert_weight=True) -> float: ...
+def effective_graph_resistance(G, weight: str | None = None, invert_weight: bool = True) -> float: ...
 @_dispatchable
-def kemeny_constant(G, *, weight=None) -> float: ...
+def kemeny_constant(G, *, weight: str | None = None) -> float: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/dominating.pyi

@@ -3,9 +3,13 @@ from collections.abc import Iterable
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
-__all__ = ["dominating_set", "is_dominating_set"]
+__all__ = ["dominating_set", "is_dominating_set", "connected_dominating_set", "is_connected_dominating_set"]
 
 @_dispatchable
-def dominating_set(G: Graph[_Node], start_with: _Node | None = None): ...
+def dominating_set(G: Graph[_Node], start_with: _Node | None = None) -> set[_Node]: ...
 @_dispatchable
 def is_dominating_set(G: Graph[_Node], nbunch: Iterable[_Node]) -> bool: ...
+@_dispatchable
+def connected_dominating_set(G: Graph[_Node]) -> set[_Node]: ...
+@_dispatchable
+def is_connected_dominating_set(G: Graph[_Node], nbunch: Iterable[_Node]) -> bool: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/isomorphism/isomorph.pyi

@@ -1,5 +1,6 @@
 from _typeshed import Incomplete
 from collections.abc import Callable
+from typing_extensions import deprecated
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -7,24 +8,27 @@ from networkx.utils.backends import _dispatchable
 __all__ = ["could_be_isomorphic", "fast_could_be_isomorphic", "faster_could_be_isomorphic", "is_isomorphic"]
 
 @_dispatchable
-def could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]): ...
-
-graph_could_be_isomorphic = could_be_isomorphic
-
+def could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node], *, properties: str = "dtc") -> bool: ...
+@deprecated("`graph_could_be_isomorphic` is a deprecated alias for `could_be_isomorphic`. Use `could_be_isomorphic` instead.")
+def graph_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]) -> bool: ...
 @_dispatchable
-def fast_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]): ...
-
-fast_graph_could_be_isomorphic = fast_could_be_isomorphic
-
+def fast_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]) -> bool: ...
+@deprecated(
+    "`fast_graph_could_be_isomorphic` is a deprecated alias for `fast_could_be_isomorphic`. "
+    "Use `fast_could_be_isomorphic` instead."
+)
+def fast_graph_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]) -> bool: ...
 @_dispatchable
-def faster_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]): ...
-
-faster_graph_could_be_isomorphic = faster_could_be_isomorphic
-
+def faster_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]) -> bool: ...
+@deprecated(
+    "`faster_graph_could_be_isomorphic` is a deprecated alias for `faster_could_be_isomorphic`. "
+    "Use `faster_could_be_isomorphic` instead."
+)
+def faster_graph_could_be_isomorphic(G1: Graph[_Node], G2: Graph[_Node]) -> bool: ...
 @_dispatchable
 def is_isomorphic(
     G1: Graph[_Node],
     G2: Graph[_Node],
     node_match: Callable[..., Incomplete] | None = None,
     edge_match: Callable[..., Incomplete] | None = None,
-): ...
+) -> bool: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/isomorphism/matchhelpers.pyi

@@ -1,4 +1,5 @@
 from _typeshed import Incomplete
+from types import FunctionType
 
 from networkx.utils.backends import _dispatchable
 
@@ -14,6 +15,8 @@ __all__ = [
     "generic_multiedge_match",
 ]
 
+def copyfunc(f, name=None) -> FunctionType: ...
+def allclose(x, y, rtol: float = 1.0000000000000001e-05, atol=1e-08) -> bool: ...
 @_dispatchable
 def categorical_node_match(attr, default): ...
 

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/isomorphism/tree_isomorphism.pyi

@@ -3,6 +3,8 @@ from networkx.utils.backends import _dispatchable
 
 __all__ = ["rooted_tree_isomorphism", "tree_isomorphism"]
 
+@_dispatchable
+def root_trees(t1, root1, t2, root2): ...
 @_dispatchable
 def rooted_tree_isomorphism(t1, root1, t2, root2): ...
 @_dispatchable

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/minors/contraction.pyi

@@ -20,9 +20,18 @@ def quotient_graph(
     create_using: Graph[_Node] | None = None,
 ): ...
 @_dispatchable
-def contracted_nodes(G: Graph[_Node], u, v, self_loops: bool = True, copy: bool = True): ...
+def contracted_nodes(
+    G: Graph[_Node], u, v, self_loops: bool = True, copy: bool = True, *, store_contraction_as: str | None = "contraction"
+): ...
 
 identified_nodes = contracted_nodes
 
 @_dispatchable
-def contracted_edge(G: Graph[_Node], edge: tuple[Incomplete], self_loops: bool = True, copy: bool = True): ...
+def contracted_edge(
+    G: Graph[_Node],
+    edge: tuple[Incomplete],
+    self_loops: bool = True,
+    copy: bool = True,
+    *,
+    store_contraction_as: str | None = "contraction",
+): ...