basedpyright 1.28.3 → 1.28.4

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

@@ -1,10 +1,11 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def maximum_independent_set(G): ...
+def maximum_independent_set(G: Graph[_Node]): ...
 @_dispatchable
-def max_clique(G): ...
+def max_clique(G: Graph[_Node]): ...
 @_dispatchable
-def clique_removal(G): ...
+def clique_removal(G: Graph[_Node]): ...
 @_dispatchable
-def large_clique_size(G): ...
+def large_clique_size(G: Graph[_Node]): ...

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

@@ -1,6 +1,6 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def average_clustering(G, trials: int = 1000, seed: Incomplete | None = None): ...
+def average_clustering(G: Graph[_Node], trials: int = 1000, seed: int | RandomState | None = None): ...

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

@@ -1,10 +1,12 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def local_node_connectivity(G, source, target, cutoff: Incomplete | None = None): ...
+def local_node_connectivity(G: Graph[_Node], source: _Node, target: _Node, cutoff: int | None = None): ...
 @_dispatchable
-def node_connectivity(G, s: Incomplete | None = None, t: Incomplete | None = None): ...
+def node_connectivity(G: Graph[_Node], s: _Node | None = None, t: _Node | None = None): ...
 @_dispatchable
-def all_pairs_node_connectivity(G, nbunch: Incomplete | None = None, cutoff: Incomplete | None = None): ...
+def all_pairs_node_connectivity(G: Graph[_Node], nbunch: Iterable[Incomplete] | None = None, cutoff: int | None = None): ...

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

@@ -1,6 +1,6 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def diameter(G, seed: Incomplete | None = None): ...
+def diameter(G: Graph[_Node], seed: int | RandomState | None = None): ...

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

@@ -1,8 +1,7 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def min_weighted_dominating_set(G, weight: Incomplete | None = None): ...
+def min_weighted_dominating_set(G: Graph[_Node], weight: str | None = None): ...
 @_dispatchable
-def min_edge_dominating_set(G): ...
+def min_edge_dominating_set(G: Graph[_Node]): ...

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

@@ -1,4 +1,5 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def k_components(G, min_density: float = 0.95): ...
+def k_components(G: Graph[_Node], min_density: float = 0.95): ...

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

@@ -1,4 +1,5 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def min_maximal_matching(G): ...
+def min_maximal_matching(G: Graph[_Node]): ...

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

@@ -1,8 +1,14 @@
 from _typeshed import Incomplete
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def randomized_partitioning(G, seed: Incomplete | None = None, p: float = 0.5, weight: Incomplete | None = None): ...
+def randomized_partitioning(
+    G: Graph[_Node], seed: int | RandomState | None = None, p: float = 0.5, weight: str | None = None
+): ...
 @_dispatchable
-def one_exchange(G, initial_cut: Incomplete | None = None, seed: Incomplete | None = None, weight: Incomplete | None = None): ...
+def one_exchange(
+    G: Graph[_Node], initial_cut: set[Incomplete] | None = None, seed: int | RandomState | None = None, weight: str | None = None
+): ...

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

@@ -1,4 +1,5 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def ramsey_R2(G): ...
+def ramsey_R2(G: Graph[_Node]): ...

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

@@ -1,8 +1,10 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def metric_closure(G, weight: str = "weight"): ...
+def metric_closure(G: Graph[_Node], weight="weight"): ...
 @_dispatchable
-def steiner_tree(G, terminal_nodes, weight: str = "weight", method: Incomplete | None = None): ...
+def steiner_tree(G: Graph[_Node], terminal_nodes: Iterable[Incomplete], weight: str = "weight", method: str | None = None): ...

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

@@ -1,41 +1,51 @@
 from _typeshed import Incomplete
+from collections.abc import Callable
 
+from networkx.classes.digraph import DiGraph
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def christofides(G, weight: str = "weight", tree: Incomplete | None = None): ...
+def christofides(G: Graph[_Node], weight: str | None = "weight", tree: Graph[_Node] | None = None): ...
 @_dispatchable
 def traveling_salesman_problem(
-    G, weight: str = "weight", nodes: Incomplete | None = None, cycle: bool = True, method: Incomplete | None = None, **kwargs
+    G: Graph[_Node],
+    weight: str = "weight",
+    nodes=None,
+    cycle: bool = True,
+    method: Callable[..., Incomplete] | None = None,
+    **kwargs,
 ): ...
 @_dispatchable
-def asadpour_atsp(G, weight: str = "weight", seed: Incomplete | None = None, source: Incomplete | None = None): ...
+def asadpour_atsp(
+    G: DiGraph[_Node], weight: str | None = "weight", seed: int | RandomState | None = None, source: str | None = None
+): ...
 @_dispatchable
-def greedy_tsp(G, weight: str = "weight", source: Incomplete | None = None): ...
+def greedy_tsp(G: Graph[_Node], weight: str | None = "weight", source=None): ...
 @_dispatchable
 def simulated_annealing_tsp(
-    G,
+    G: Graph[_Node],
     init_cycle,
-    weight: str = "weight",
-    source: Incomplete | None = None,
-    # docstring says int, but it can be a float and does become a float mid-equation if alpha is also a float
-    temp: float = 100,
-    move: str = "1-1",
-    max_iterations: int = 10,
-    N_inner: int = 100,
-    alpha: float = 0.01,
-    seed: Incomplete | None = None,
+    weight: str | None = "weight",
+    source=None,
+    temp: int | None = 100,
+    move="1-1",
+    max_iterations: int | None = 10,
+    N_inner: int | None = 100,
+    alpha=0.01,
+    seed: int | RandomState | None = None,
 ): ...
 @_dispatchable
 def threshold_accepting_tsp(
-    G,
+    G: Graph[_Node],
     init_cycle,
-    weight: str = "weight",
-    source: Incomplete | None = None,
-    threshold: float = 1,
-    move: str = "1-1",
-    max_iterations: int = 10,
-    N_inner: int = 100,
-    alpha: float = 0.1,
-    seed: Incomplete | None = None,
+    weight: str | None = "weight",
+    source=None,
+    threshold: int | None = 1,
+    move="1-1",
+    max_iterations: int | None = 10,
+    N_inner: int | None = 100,
+    alpha=0.1,
+    seed: int | RandomState | None = None,
 ): ...

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

@@ -1,15 +1,17 @@
 from _typeshed import Incomplete
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 __all__ = ["treewidth_min_degree", "treewidth_min_fill_in"]
 
 @_dispatchable
-def treewidth_min_degree(G): ...
+def treewidth_min_degree(G: Graph[_Node]): ...
 @_dispatchable
-def treewidth_min_fill_in(G): ...
+def treewidth_min_fill_in(G: Graph[_Node]): ...
 
 class MinDegreeHeuristic:
     count: Incomplete
+
     def __init__(self, graph) -> None: ...
     def best_node(self, graph): ...

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

@@ -1,6 +1,5 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def min_weighted_vertex_cover(G, weight: Incomplete | None = None): ...
+def min_weighted_vertex_cover(G: Graph[_Node], weight: str | None = None): ...

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

@@ -1,8 +1,10 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def average_degree_connectivity(
-    G, source: str = "in+out", target: str = "in+out", nodes: Incomplete | None = None, weight: Incomplete | None = None
+    G: Graph[_Node], source="in+out", target="in+out", nodes: Iterable[Incomplete] | None = None, weight: str | None = None
 ): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/assortativity/correlation.pyi

@@ -1,16 +1,18 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def degree_assortativity_coefficient(
-    G, x: str = "out", y: str = "in", weight: Incomplete | None = None, nodes: Incomplete | None = None
+    G: Graph[_Node], x: str = "out", y: str = "in", weight: str | None = None, nodes: Iterable[Incomplete] | None = None
 ): ...
 @_dispatchable
 def degree_pearson_correlation_coefficient(
-    G, x: str = "out", y: str = "in", weight: Incomplete | None = None, nodes: Incomplete | None = None
+    G: Graph[_Node], x: str = "out", y: str = "in", weight: str | None = None, nodes: Iterable[Incomplete] | None = None
 ): ...
 @_dispatchable
-def attribute_assortativity_coefficient(G, attribute, nodes: Incomplete | None = None): ...
+def attribute_assortativity_coefficient(G: Graph[_Node], attribute: str, nodes: Iterable[Incomplete] | None = None): ...
 @_dispatchable
-def numeric_assortativity_coefficient(G, attribute, nodes: Incomplete | None = None): ...
+def numeric_assortativity_coefficient(G: Graph[_Node], attribute: str, nodes: Iterable[Incomplete] | None = None): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/assortativity/mixing.pyi

@@ -1,26 +1,34 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def attribute_mixing_dict(G, attribute, nodes: Incomplete | None = None, normalized: bool = False): ...
+def attribute_mixing_dict(
+    G: Graph[_Node], attribute: str, nodes: Iterable[Incomplete] | None = None, normalized: bool = False
+): ...
 @_dispatchable
 def attribute_mixing_matrix(
-    G, attribute, nodes: Incomplete | None = None, mapping: Incomplete | None = None, normalized: bool = True
+    G: Graph[_Node],
+    attribute: str,
+    nodes: Iterable[Incomplete] | None = None,
+    mapping: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    normalized: bool = True,
 ): ...
 @_dispatchable
 def degree_mixing_dict(
-    G, x: str = "out", y: str = "in", weight: Incomplete | None = None, nodes: Incomplete | None = None, normalized: bool = False
+    G: Graph[_Node], x: str = "out", y: str = "in", weight: str | None = None, nodes=None, normalized: bool = False
 ): ...
 @_dispatchable
 def degree_mixing_matrix(
-    G,
+    G: Graph[_Node],
     x: str = "out",
     y: str = "in",
-    weight: Incomplete | None = None,
-    nodes: Incomplete | None = None,
+    weight: str | None = None,
+    nodes: Iterable[Incomplete] | None = None,
     normalized: bool = True,
-    mapping: Incomplete | None = None,
+    mapping: SupportsGetItem[Incomplete, Incomplete] | None = None,
 ): ...
 @_dispatchable
 def mixing_dict(xy, normalized: bool = False): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/assortativity/neighbor_degree.pyi

@@ -1,8 +1,14 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def average_neighbor_degree(
-    G, source: str = "out", target: str = "out", nodes: Incomplete | None = None, weight: Incomplete | None = None
+    G: Graph[_Node],
+    source: str | None = "out",
+    target: str | None = "out",
+    nodes: Iterable[Incomplete] | None = None,
+    weight: str | None = None,
 ): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/assortativity/pairs.pyi

@@ -1,11 +1,14 @@
 from _typeshed import Incomplete
-from collections.abc import Generator
+from collections.abc import Generator, Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def node_attribute_xy(G, attribute, nodes: Incomplete | None = None) -> Generator[Incomplete, None, None]: ...
+def node_attribute_xy(
+    G: Graph[_Node], attribute, nodes: Iterable[Incomplete] | None = None
+) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def node_degree_xy(
-    G, x: str = "out", y: str = "in", weight: Incomplete | None = None, nodes: Incomplete | None = None
+    G: Graph[_Node], x: str = "out", y: str = "in", weight: str | None = None, nodes: Iterable[Incomplete] | None = None
 ) -> Generator[Incomplete, None, None]: ...

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

@@ -1,6 +1,7 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def find_asteroidal_triple(G): ...
+def find_asteroidal_triple(G: Graph[_Node]): ...
 @_dispatchable
-def is_at_free(G): ...
+def is_at_free(G: Graph[_Node]): ...

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

@@ -3,6 +3,7 @@ from networkx.algorithms.bipartite.centrality import *
 from networkx.algorithms.bipartite.cluster import *
 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.matching import *
 from networkx.algorithms.bipartite.matrix import *

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

@@ -1,16 +1,18 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def color(G): ...
+def color(G: Graph[_Node]): ...
 @_dispatchable
-def is_bipartite(G): ...
+def is_bipartite(G: Graph[_Node]): ...
 @_dispatchable
-def is_bipartite_node_set(G, nodes): ...
+def is_bipartite_node_set(G: Graph[_Node], nodes): ...
 @_dispatchable
-def sets(G, top_nodes: Incomplete | None = None): ...
+def sets(G: Graph[_Node], top_nodes: Iterable[Incomplete] | None = None): ...
 @_dispatchable
-def density(B, nodes): ...
+def density(B: Graph[_Node], nodes): ...
 @_dispatchable
-def degrees(B, nodes, weight: Incomplete | None = None): ...
+def degrees(B: Graph[_Node], nodes, weight: str | None = None): ...

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

@@ -1,8 +1,9 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def degree_centrality(G, nodes): ...
+def degree_centrality(G: Graph[_Node], nodes): ...
 @_dispatchable
-def betweenness_centrality(G, nodes): ...
+def betweenness_centrality(G: Graph[_Node], nodes): ...
 @_dispatchable
-def closeness_centrality(G, nodes, normalized: bool = True): ...
+def closeness_centrality(G: Graph[_Node], nodes, normalized: bool | None = True): ...

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

@@ -1,13 +1,15 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def latapy_clustering(G, nodes: Incomplete | None = None, mode: str = "dot"): ...
+def latapy_clustering(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None, mode: str = "dot"): ...
 
 clustering = latapy_clustering
 
 @_dispatchable
-def average_clustering(G, nodes: Incomplete | None = None, mode: str = "dot"): ...
+def average_clustering(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None, mode: str = "dot"): ...
 @_dispatchable
-def robins_alexander_clustering(G): ...
+def robins_alexander_clustering(G: Graph[_Node]): ...

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

@@ -1,6 +1,8 @@
 from _typeshed import Incomplete
+from collections.abc import Callable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def min_edge_cover(G, matching_algorithm: Incomplete | None = None): ...
+def min_edge_cover(G: Graph[_Node], matching_algorithm: Callable[..., Incomplete] | None = None): ...

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

@@ -1,6 +1,7 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
@@ -10,20 +11,20 @@ def generate_edgelist(G, delimiter: str = " ", data: bool = True) -> Generator[I
 @_dispatchable
 def parse_edgelist(
     lines,
-    comments: str = "#",
-    delimiter: Incomplete | None = None,
-    create_using: Incomplete | None = None,
-    nodetype: Incomplete | None = None,
-    data: bool = True,
+    comments: str | None = "#",
+    delimiter: str | None = None,
+    create_using: Graph[_Node] | None = None,
+    nodetype=None,
+    data=True,
 ): ...
 @_dispatchable
 def read_edgelist(
     path,
-    comments: str = "#",
-    delimiter: Incomplete | None = None,
-    create_using: Incomplete | None = None,
-    nodetype: Incomplete | None = None,
-    data: bool = True,
-    edgetype: Incomplete | None = None,
-    encoding: str = "utf-8",
+    comments: str | None = "#",
+    delimiter: str | None = None,
+    create_using=None,
+    nodetype=None,
+    data=True,
+    edgetype=None,
+    encoding: str | None = "utf-8",
 ): ...

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

@@ -0,0 +1,5 @@
+from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
+
+@_dispatchable
+def maximal_extendability(G: Graph[_Node]): ...

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

@@ -1,20 +1,34 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def complete_bipartite_graph(n1, n2, create_using: Incomplete | None = None): ...
+def complete_bipartite_graph(n1, n2, create_using: Graph[_Node] | None = None): ...
 @_dispatchable
-def configuration_model(aseq, bseq, create_using: Incomplete | None = None, seed: Incomplete | None = None): ...
+def configuration_model(
+    aseq: Iterable[Incomplete],
+    bseq: Iterable[Incomplete],
+    create_using: Graph[_Node] | None = None,
+    seed: int | RandomState | None = None,
+): ...
 @_dispatchable
-def havel_hakimi_graph(aseq, bseq, create_using: Incomplete | None = None): ...
+def havel_hakimi_graph(aseq: Iterable[Incomplete], bseq: Iterable[Incomplete], create_using: Graph[_Node] | None = None): ...
 @_dispatchable
-def reverse_havel_hakimi_graph(aseq, bseq, create_using: Incomplete | None = None): ...
+def reverse_havel_hakimi_graph(
+    aseq: Iterable[Incomplete], bseq: Iterable[Incomplete], create_using: Graph[_Node] | None = None
+): ...
 @_dispatchable
-def alternating_havel_hakimi_graph(aseq, bseq, create_using: Incomplete | None = None): ...
+def alternating_havel_hakimi_graph(
+    aseq: Iterable[Incomplete], bseq: Iterable[Incomplete], create_using: Graph[_Node] | None = None
+): ...
 @_dispatchable
-def preferential_attachment_graph(aseq, p, create_using: Incomplete | None = None, seed: Incomplete | None = None): ...
+def preferential_attachment_graph(
+    aseq: Iterable[Incomplete], p: float, create_using: Graph[_Node] | None = None, seed: int | RandomState | None = None
+): ...
 @_dispatchable
-def random_graph(n, m, p, seed: Incomplete | None = None, directed: bool = False): ...
+def random_graph(n: int, m: int, p: float, seed: int | RandomState | None = None, directed: bool | None = False): ...
 @_dispatchable
-def gnmk_random_graph(n, m, k, seed: Incomplete | None = None, directed: bool = False): ...
+def gnmk_random_graph(n: int, m: int, k: int, seed: int | RandomState | None = None, directed: bool | None = False): ...

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

@@ -1,15 +1,21 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def hopcroft_karp_matching(G, top_nodes: Incomplete | None = None): ...
+def hopcroft_karp_matching(G: Graph[_Node], top_nodes: Iterable[_Node] | None = None): ...
 @_dispatchable
-def eppstein_matching(G, top_nodes: Incomplete | None = None): ...
+def eppstein_matching(G: Graph[_Node], top_nodes: Iterable[Incomplete] | None = None): ...
 @_dispatchable
-def to_vertex_cover(G, matching, top_nodes: Incomplete | None = None): ...
+def to_vertex_cover(
+    G: Graph[_Node], matching: SupportsGetItem[Incomplete, Incomplete], top_nodes: Iterable[Incomplete] | None = None
+): ...
 
 maximum_matching = hopcroft_karp_matching
 
 @_dispatchable
-def minimum_weight_full_matching(G, top_nodes: Incomplete | None = None, weight: str = "weight"): ...
+def minimum_weight_full_matching(
+    G: Graph[_Node], top_nodes: Iterable[Incomplete] | None = None, weight: str | None = "weight"
+): ...

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

@@ -1,15 +1,17 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def biadjacency_matrix(
-    G,
-    row_order,
-    column_order: Incomplete | None = None,
-    dtype: Incomplete | None = None,
-    weight: str = "weight",
-    format: str = "csr",
+    G: Graph[_Node],
+    row_order: Iterable[_Node],
+    column_order: Iterable[Incomplete] | None = None,
+    dtype=None,
+    weight: str | None = "weight",
+    format="csr",
 ): ...
 @_dispatchable
-def from_biadjacency_matrix(A, create_using: Incomplete | None = None, edge_attribute: str = "weight"): ...
+def from_biadjacency_matrix(A, create_using: Graph[_Node] | None = None, edge_attribute: str = "weight"): ...

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

@@ -1,14 +1,18 @@
 from _typeshed import Incomplete
+from collections.abc import Callable, Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def projected_graph(B, nodes, multigraph: bool = False): ...
+def projected_graph(B: Graph[_Node], nodes: Iterable[Incomplete], multigraph: bool = False): ...
 @_dispatchable
-def weighted_projected_graph(B, nodes, ratio: bool = False): ...
+def weighted_projected_graph(B: Graph[_Node], nodes: Iterable[Incomplete], ratio: bool = False): ...
 @_dispatchable
-def collaboration_weighted_projected_graph(B, nodes): ...
+def collaboration_weighted_projected_graph(B: Graph[_Node], nodes: Iterable[Incomplete]): ...
 @_dispatchable
-def overlap_weighted_projected_graph(B, nodes, jaccard: bool = True): ...
+def overlap_weighted_projected_graph(B: Graph[_Node], nodes: Iterable[Incomplete], jaccard: bool = True): ...
 @_dispatchable
-def generic_weighted_projected_graph(B, nodes, weight_function: Incomplete | None = None): ...
+def generic_weighted_projected_graph(
+    B: Graph[_Node], nodes: Iterable[Incomplete], weight_function: Callable[..., Incomplete] | None = None
+): ...

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

@@ -1,6 +1,8 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def node_redundancy(G, nodes: Incomplete | None = None): ...
+def node_redundancy(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None): ...

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

@@ -1,6 +1,5 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def spectral_bipartivity(G, nodes: Incomplete | None = None, weight: str = "weight"): ...
+def spectral_bipartivity(G: Graph[_Node], nodes=None, weight: str = "weight"): ...