basedpyright 1.28.3 → 1.28.4

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/shortest_paths/generic.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from typing import overload
 
 from networkx.classes.graph import Graph, _Node
@@ -9,23 +9,45 @@ from networkx.utils.backends import _dispatchable
 def has_path(G: Graph[_Node], source: _Node, target: _Node) -> bool: ...
 @overload
 def shortest_path(
-    G: Graph[_Node], source: _Node, target: _Node, weight: Incomplete | None = None, method: str = "dijkstra"
+    G: Graph[_Node],
+    source: _Node | None = None,
+    target: _Node | None = None,
+    weight: str | Callable[..., Incomplete] | None = None,
+    method: str | None = "dijkstra",
 ) -> list[_Node]: ...
 @overload
-def shortest_path(G: Graph[_Node], target: _Node, method: str = "dijkstra") -> dict[_Node, list[_Node]]: ...
+def shortest_path(
+    G: Graph[_Node],
+    source: _Node | None = None,
+    target: _Node | None = None,
+    weight: str | Callable[..., Incomplete] | None = None,
+    method: str | None = "dijkstra",
+) -> dict[_Node, list[_Node]]: ...
 @overload
-def shortest_path(G: Graph[_Node], source: _Node, method: str = "dijkstra") -> dict[_Node, list[_Node]]: ...
+def shortest_path(
+    G: Graph[_Node],
+    source: _Node | None = None,
+    target: _Node | None = None,
+    weight: str | Callable[..., Incomplete] | None = None,
+    method: str | None = "dijkstra",
+) -> dict[_Node, list[_Node]]: ...
 @_dispatchable
 def shortest_path_length(
-    G,
-    source: Incomplete | None = None,
-    target: Incomplete | None = None,
-    weight: Incomplete | None = None,
-    method: str = "dijkstra",
+    G: Graph[_Node],
+    source: _Node | None = None,
+    target: _Node | None = None,
+    weight: str | Callable[..., Incomplete] | None = None,
+    method: str | None = "dijkstra",
 ): ...
 @_dispatchable
-def average_shortest_path_length(G, weight: Incomplete | None = None, method: str | None = None): ...
+def average_shortest_path_length(
+    G: Graph[_Node], weight: str | Callable[..., Incomplete] | None = None, method: str | None = None
+): ...
 @_dispatchable
 def all_shortest_paths(
-    G: Graph[_Node], source: _Node, target: _Node, weight: Incomplete | None = None, method: str = "dijkstra"
+    G: Graph[_Node],
+    source: _Node,
+    target: _Node,
+    weight: str | Callable[..., Incomplete] | None = None,
+    method: str | None = "dijkstra",
 ) -> Generator[list[_Node], None, None]: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/shortest_paths/unweighted.pyi

@@ -1,23 +1,24 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def single_source_shortest_path_length(G, source, cutoff: Incomplete | None = None): ...
+def single_source_shortest_path_length(G: Graph[_Node], source: _Node, cutoff: int | None = None): ...
 @_dispatchable
-def single_target_shortest_path_length(G, target, cutoff: Incomplete | None = None): ...
+def single_target_shortest_path_length(G: Graph[_Node], target: _Node, cutoff: int | None = None): ...
 @_dispatchable
-def all_pairs_shortest_path_length(G, cutoff: Incomplete | None = None) -> Generator[Incomplete, None, None]: ...
+def all_pairs_shortest_path_length(G: Graph[_Node], cutoff: int | None = None) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
-def bidirectional_shortest_path(G, source, target): ...
+def bidirectional_shortest_path(G: Graph[_Node], source: str, target: str): ...
 @_dispatchable
-def single_source_shortest_path(G, source, cutoff: Incomplete | None = None): ...
+def single_source_shortest_path(G: Graph[_Node], source: str, cutoff: int | None = None): ...
 @_dispatchable
-def single_target_shortest_path(G, target, cutoff: Incomplete | None = None): ...
+def single_target_shortest_path(G: Graph[_Node], target: str, cutoff: int | None = None): ...
 @_dispatchable
-def all_pairs_shortest_path(G, cutoff: Incomplete | None = None) -> Generator[Incomplete, None, None]: ...
+def all_pairs_shortest_path(G: Graph[_Node], cutoff: int | None = None) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def predecessor(
-    G, source, target: Incomplete | None = None, cutoff: Incomplete | None = None, return_seen: Incomplete | None = None
+    G: Graph[_Node], source: str, target: str | None = None, cutoff: int | None = None, return_seen: bool | None = None
 ): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/shortest_paths/weighted.pyi

@@ -1,72 +1,158 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
 from collections.abc import Callable, Generator
 from typing import Any
-from typing_extensions import TypeAlias
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
-# type alias for the weight function
-_WeightFunction: TypeAlias = Callable[[Any, Any, dict[str, Any]], float | None]
-
 @_dispatchable
-def dijkstra_path(G, source, target, weight: str | _WeightFunction = "weight"): ...
+def dijkstra_path(
+    G: Graph[_Node],
+    source: _Node,
+    target: _Node,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def dijkstra_path_length(G, source, target, weight: str | _WeightFunction = "weight"): ...
+def dijkstra_path_length(
+    G: Graph[_Node],
+    source: str,
+    target: str,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def single_source_dijkstra_path(G, source, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def single_source_dijkstra_path(
+    G: Graph[_Node],
+    source: _Node,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def single_source_dijkstra_path_length(G, source, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def single_source_dijkstra_path_length(
+    G: Graph[_Node],
+    source: str,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
 def single_source_dijkstra(
-    G, source, target: Incomplete | None = None, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"
+    G: Graph[_Node],
+    source: str,
+    target: str | None = None,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
 ): ...
 @_dispatchable
-def multi_source_dijkstra_path(G, sources, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def multi_source_dijkstra_path(
+    G: Graph[_Node],
+    sources,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def multi_source_dijkstra_path_length(G, sources, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def multi_source_dijkstra_path_length(
+    G: Graph[_Node],
+    sources,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
 def multi_source_dijkstra(
-    G, sources, target: Incomplete | None = None, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"
+    G: Graph[_Node],
+    sources,
+    target: str | None = None,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
 ): ...
 @_dispatchable
-def dijkstra_predecessor_and_distance(G, source, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def dijkstra_predecessor_and_distance(
+    G: Graph[_Node],
+    source: str,
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
 def all_pairs_dijkstra(
-    G, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"
+    G: Graph[_Node],
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
 ) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def all_pairs_dijkstra_path_length(
-    G, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"
+    G: Graph[_Node],
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
 ) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def all_pairs_dijkstra_path(
-    G, cutoff: Incomplete | None = None, weight: str | _WeightFunction = "weight"
+    G: Graph[_Node],
+    cutoff: float | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
 ) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def bellman_ford_predecessor_and_distance(
-    G, source, target: Incomplete | None = None, weight: str | _WeightFunction = "weight", heuristic: bool = False
+    G: Graph[_Node],
+    source: str,
+    target: str | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+    heuristic: bool = False,
 ): ...
 @_dispatchable
-def bellman_ford_path(G, source, target, weight: str | _WeightFunction = "weight"): ...
+def bellman_ford_path(
+    G: Graph[_Node],
+    source: _Node,
+    target: _Node,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def bellman_ford_path_length(G, source, target, weight: str | _WeightFunction = "weight"): ...
+def bellman_ford_path_length(
+    G: Graph[_Node],
+    source: str,
+    target: str,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def single_source_bellman_ford_path(G, source, weight: str | _WeightFunction = "weight"): ...
+def single_source_bellman_ford_path(
+    G: Graph[_Node], source: _Node, weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+): ...
 @_dispatchable
-def single_source_bellman_ford_path_length(G, source, weight: str | _WeightFunction = "weight"): ...
+def single_source_bellman_ford_path_length(
+    G: Graph[_Node], source: str, weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+): ...
 @_dispatchable
-def single_source_bellman_ford(G, source, target: Incomplete | None = None, weight: str | _WeightFunction = "weight"): ...
+def single_source_bellman_ford(
+    G: Graph[_Node],
+    source: str,
+    target: str | None = None,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def all_pairs_bellman_ford_path_length(G, weight: str | _WeightFunction = "weight") -> Generator[Incomplete, None, None]: ...
+def all_pairs_bellman_ford_path_length(
+    G: Graph[_Node], weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
-def all_pairs_bellman_ford_path(G, weight: str | _WeightFunction = "weight") -> Generator[Incomplete, None, None]: ...
+def all_pairs_bellman_ford_path(
+    G: Graph[_Node], weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
-def goldberg_radzik(G, source, weight: str | _WeightFunction = "weight"): ...
+def goldberg_radzik(
+    G: Graph[_Node], source: str, weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+): ...
 @_dispatchable
-def negative_edge_cycle(G, weight: str | _WeightFunction = "weight", heuristic: bool = True): ...
+def negative_edge_cycle(
+    G: Graph[_Node],
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+    heuristic: bool = True,
+): ...
 @_dispatchable
-def find_negative_cycle(G, source, weight: str | _WeightFunction = "weight"): ...
+def find_negative_cycle(
+    G: Graph[_Node], source: str, weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"
+): ...
 @_dispatchable
-def bidirectional_dijkstra(G, source, target, weight: str | _WeightFunction = "weight"): ...
+def bidirectional_dijkstra(
+    G: Graph[_Node],
+    source: _Node,
+    target: _Node,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight",
+): ...
 @_dispatchable
-def johnson(G, weight: str | _WeightFunction = "weight"): ...
+def johnson(G: Graph[_Node], weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = "weight"): ...

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

@@ -1,83 +1,97 @@
-from _typeshed import Incomplete
-from collections.abc import Generator
+from _typeshed import Incomplete, SupportsGetItem
+from collections.abc import Callable, Generator
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
 def graph_edit_distance(
-    G1,
-    G2,
-    node_match: Incomplete | None = None,
-    edge_match: Incomplete | None = None,
-    node_subst_cost: Incomplete | None = None,
-    node_del_cost: Incomplete | None = None,
-    node_ins_cost: Incomplete | None = None,
-    edge_subst_cost: Incomplete | None = None,
-    edge_del_cost: Incomplete | None = None,
-    edge_ins_cost: Incomplete | None = None,
-    roots: Incomplete | None = None,
-    upper_bound: Incomplete | None = None,
-    timeout: Incomplete | None = None,
+    G1: Graph[_Node],
+    G2: Graph[_Node],
+    node_match: Callable[..., Incomplete] | None = None,
+    edge_match: Callable[..., Incomplete] | None = None,
+    node_subst_cost: Callable[..., Incomplete] | None = None,
+    node_del_cost: Callable[..., Incomplete] | None = None,
+    node_ins_cost: Callable[..., Incomplete] | None = None,
+    edge_subst_cost: Callable[..., Incomplete] | None = None,
+    edge_del_cost: Callable[..., Incomplete] | None = None,
+    edge_ins_cost: Callable[..., Incomplete] | None = None,
+    roots=None,
+    upper_bound: float | None = None,
+    timeout: float | None = None,
 ): ...
 @_dispatchable
 def optimal_edit_paths(
-    G1,
-    G2,
-    node_match: Incomplete | None = None,
-    edge_match: Incomplete | None = None,
-    node_subst_cost: Incomplete | None = None,
-    node_del_cost: Incomplete | None = None,
-    node_ins_cost: Incomplete | None = None,
-    edge_subst_cost: Incomplete | None = None,
-    edge_del_cost: Incomplete | None = None,
-    edge_ins_cost: Incomplete | None = None,
-    upper_bound: Incomplete | None = None,
+    G1: Graph[_Node],
+    G2: Graph[_Node],
+    node_match: Callable[..., Incomplete] | None = None,
+    edge_match: Callable[..., Incomplete] | None = None,
+    node_subst_cost: Callable[..., Incomplete] | None = None,
+    node_del_cost: Callable[..., Incomplete] | None = None,
+    node_ins_cost: Callable[..., Incomplete] | None = None,
+    edge_subst_cost: Callable[..., Incomplete] | None = None,
+    edge_del_cost: Callable[..., Incomplete] | None = None,
+    edge_ins_cost: Callable[..., Incomplete] | None = None,
+    upper_bound: float | None = None,
 ): ...
 @_dispatchable
 def optimize_graph_edit_distance(
-    G1,
-    G2,
-    node_match: Incomplete | None = None,
-    edge_match: Incomplete | None = None,
-    node_subst_cost: Incomplete | None = None,
-    node_del_cost: Incomplete | None = None,
-    node_ins_cost: Incomplete | None = None,
-    edge_subst_cost: Incomplete | None = None,
-    edge_del_cost: Incomplete | None = None,
-    edge_ins_cost: Incomplete | None = None,
-    upper_bound: Incomplete | None = None,
+    G1: Graph[_Node],
+    G2: Graph[_Node],
+    node_match: Callable[..., Incomplete] | None = None,
+    edge_match: Callable[..., Incomplete] | None = None,
+    node_subst_cost: Callable[..., Incomplete] | None = None,
+    node_del_cost: Callable[..., Incomplete] | None = None,
+    node_ins_cost: Callable[..., Incomplete] | None = None,
+    edge_subst_cost: Callable[..., Incomplete] | None = None,
+    edge_del_cost: Callable[..., Incomplete] | None = None,
+    edge_ins_cost: Callable[..., Incomplete] | None = None,
+    upper_bound: float | None = None,
 ) -> Generator[Incomplete, None, None]: ...
 @_dispatchable
 def optimize_edit_paths(
-    G1,
-    G2,
-    node_match: Incomplete | None = None,
-    edge_match: Incomplete | None = None,
-    node_subst_cost: Incomplete | None = None,
-    node_del_cost: Incomplete | None = None,
-    node_ins_cost: Incomplete | None = None,
-    edge_subst_cost: Incomplete | None = None,
-    edge_del_cost: Incomplete | None = None,
-    edge_ins_cost: Incomplete | None = None,
-    upper_bound: Incomplete | None = None,
+    G1: Graph[_Node],
+    G2: Graph[_Node],
+    node_match: Callable[..., Incomplete] | None = None,
+    edge_match: Callable[..., Incomplete] | None = None,
+    node_subst_cost: Callable[..., Incomplete] | None = None,
+    node_del_cost: Callable[..., Incomplete] | None = None,
+    node_ins_cost: Callable[..., Incomplete] | None = None,
+    edge_subst_cost: Callable[..., Incomplete] | None = None,
+    edge_del_cost: Callable[..., Incomplete] | None = None,
+    edge_ins_cost: Callable[..., Incomplete] | None = None,
+    upper_bound: float | None = None,
     strictly_decreasing: bool = True,
-    roots: Incomplete | None = None,
-    timeout: Incomplete | None = None,
+    roots=None,
+    timeout: float | None = None,
 ) -> Generator[Incomplete, None, Incomplete]: ...
 @_dispatchable
 def simrank_similarity(
-    G,
-    source: Incomplete | None = None,
-    target: Incomplete | None = None,
+    G: Graph[_Node],
+    source: _Node | None = None,
+    target: _Node | None = None,
     importance_factor: float = 0.9,
     max_iterations: int = 1000,
     tolerance: float = 0.0001,
 ): ...
 @_dispatchable
 def panther_similarity(
-    G, source, k: int = 5, path_length: int = 5, c: float = 0.5, delta: float = 0.1, eps: Incomplete | None = None
+    G: Graph[_Node],
+    source: _Node,
+    k: int = 5,
+    path_length: int = 5,
+    c: float = 0.5,
+    delta: float = 0.1,
+    eps=None,
+    weight: str | None = "weight",
 ): ...
 @_dispatchable
 def generate_random_paths(
-    G, sample_size, path_length: int = 5, index_map: Incomplete | None = None
+    G: Graph[_Node],
+    sample_size: int,
+    path_length: int = 5,
+    index_map: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    weight: str | None = "weight",
+    seed: int | RandomState | None = None,
 ) -> Generator[Incomplete, None, None]: ...

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

@@ -1,5 +1,6 @@
-from _typeshed import Incomplete
-from collections.abc import Generator, Sequence
+from _typeshed import Incomplete, SupportsGetItem
+from collections.abc import Callable, Generator, Iterable
+from typing import Any
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -7,24 +8,26 @@ from networkx.utils.backends import _dispatchable
 __all__ = ["all_simple_paths", "is_simple_path", "shortest_simple_paths", "all_simple_edge_paths"]
 
 @_dispatchable
-def is_simple_path(G: Graph[_Node], nodes: Sequence[_Node]): ...
+def is_simple_path(G: Graph[_Node], nodes: Iterable[Incomplete]): ...
 @_dispatchable
-def all_simple_paths(
-    G: Graph[_Node], source: _Node, target: _Node, cutoff: Incomplete | None = None
-) -> Generator[list[_Node], None, None]: ...
+def all_simple_paths(G: Graph[_Node], source: _Node, target, cutoff: int | None = None) -> Generator[list[_Node], None, None]: ...
 @_dispatchable
 def all_simple_edge_paths(
-    G: Graph[_Node], source: _Node, target: _Node, cutoff: Incomplete | None = None
+    G: Graph[_Node], source: _Node, target, cutoff: int | None = None
 ) -> Generator[list[_Node] | list[tuple[_Node, _Node]], None, list[_Node] | None]: ...
 @_dispatchable
 def shortest_simple_paths(
-    G: Graph[_Node], source: _Node, target: _Node, weight: Incomplete | None = None
+    G: Graph[_Node],
+    source: _Node,
+    target: _Node,
+    weight: str | Callable[[Any, Any, SupportsGetItem[str, Any]], float | None] | None = None,
 ) -> Generator[list[_Node], None, None]: ...
 
 class PathBuffer:
     paths: Incomplete
     sortedpaths: Incomplete
     counter: Incomplete
+
     def __init__(self) -> None: ...
     def __len__(self): ...
     def push(self, cost, path) -> None: ...

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

@@ -1,14 +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 random_reference(G, niter: int = 1, connectivity: bool = True, seed: Incomplete | None = None): ...
+def random_reference(G: Graph[_Node], niter: int = 1, connectivity: bool = True, seed: int | RandomState | None = None): ...
 @_dispatchable
 def lattice_reference(
-    G, niter: int = 5, D: Incomplete | None = None, connectivity: bool = True, seed: Incomplete | None = None
+    G: Graph[_Node], niter: int = 5, D=None, connectivity: bool = True, seed: int | RandomState | None = None
 ): ...
 @_dispatchable
-def sigma(G, niter: int = 100, nrand: int = 10, seed: Incomplete | None = None): ...
+def sigma(G: Graph[_Node], niter: int = 100, nrand: int = 10, seed: int | RandomState | None = None): ...
 @_dispatchable
-def omega(G, niter: int = 5, nrand: int = 10, seed: Incomplete | None = None): ...
+def omega(G: Graph[_Node], niter: int = 5, nrand: int = 10, seed: int | RandomState | None = None): ...

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

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

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/sparsifiers.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 spanner(G, stretch, weight: Incomplete | None = None, seed: Incomplete | None = None): ...
+def spanner(G: Graph[_Node], stretch: float, weight: str | None = None, seed: int | RandomState | None = None): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/structuralholes.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 effective_size(G, nodes: Incomplete | None = None, weight: Incomplete | None = None): ...
+def effective_size(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None, weight: str | None = None): ...
 @_dispatchable
-def constraint(G, nodes: Incomplete | None = None, weight: Incomplete | None = None): ...
+def constraint(G: Graph[_Node], nodes: Iterable[Incomplete] | None = None, weight: str | None = None): ...
 @_dispatchable
-def local_constraint(G, u, v, weight: Incomplete | None = None): ...
+def local_constraint(G: Graph[_Node], u: _Node, v: _Node, weight: str | None = None): ...

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

@@ -1,14 +1,16 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def dedensify(G, threshold, prefix: Incomplete | None = None, copy: bool = True): ...
+def dedensify(G: Graph[_Node], threshold: int, prefix=None, copy: bool | None = True): ...
 @_dispatchable
 def snap_aggregation(
-    G,
+    G: Graph[_Node],
     node_attributes,
-    edge_attributes=(),
+    edge_attributes: Iterable[Incomplete] | None = (),
     prefix: str = "Supernode-",
     supernode_attribute: str = "group",
     superedge_attribute: str = "types",

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

@@ -1,10 +1,13 @@
-from _typeshed import Incomplete
-
+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 directed_edge_swap(G, *, nswap: int = 1, max_tries: int = 100, seed: Incomplete | None = None): ...
+def directed_edge_swap(G: DiGraph[_Node], *, nswap: int = 1, max_tries: int = 100, seed: int | RandomState | None = None): ...
 @_dispatchable
-def double_edge_swap(G, nswap: int = 1, max_tries: int = 100, seed: Incomplete | None = None): ...
+def double_edge_swap(G: Graph[_Node], nswap: int = 1, max_tries: int = 100, seed: int | RandomState | None = None): ...
 @_dispatchable
-def connected_double_edge_swap(G, nswap: int = 1, _window_threshold: int = 3, seed: Incomplete | None = None): ...
+def connected_double_edge_swap(
+    G: Graph[_Node], nswap: int = 1, _window_threshold: int = 3, seed: int | RandomState | None = None
+): ...

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

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

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

@@ -0,0 +1,5 @@
+from networkx.classes.graph import Graph, _Node
+from networkx.utils.backends import _dispatchable
+
+@_dispatchable
+def cd_index(G: Graph[_Node], node: _Node, time_delta, *, time: str = "time", weight: str | None = None): ...

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

@@ -1,16 +1,16 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
-def is_tournament(G): ...
+def is_tournament(G: Graph[_Node]): ...
 @_dispatchable
-def hamiltonian_path(G): ...
+def hamiltonian_path(G: Graph[_Node]): ...
 @_dispatchable
-def random_tournament(n, seed: Incomplete | None = None): ...
+def random_tournament(n: int, seed: int | RandomState | None = None): ...
 @_dispatchable
-def score_sequence(G): ...
+def score_sequence(G: Graph[_Node]): ...
 @_dispatchable
-def is_reachable(G, s, t): ...
+def is_reachable(G: Graph[_Node], s: _Node, t: _Node): ...
 @_dispatchable
-def is_strongly_connected(G): ...
+def is_strongly_connected(G: Graph[_Node]): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/traversal/beamsearch.pyi

@@ -1,7 +1,10 @@
 from _typeshed import Incomplete
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def bfs_beam_edges(G, source, value, width: Incomplete | None = None) -> Generator[Incomplete, Incomplete, Incomplete]: ...
+def bfs_beam_edges(
+    G: Graph[_Node], source: _Node, value: Callable[..., Incomplete], width: int | None = None
+) -> Generator[Incomplete, Incomplete, Incomplete]: ...