basedpyright 1.28.3 → 1.28.4

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

@@ -1,6 +1,6 @@
 from _typeshed import Incomplete
 from collections.abc import Generator, Iterable
-from typing import Literal, TypeVar, overload
+from typing import TypeVar, overload
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -10,106 +10,101 @@ _U = TypeVar("_U")
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    data: Literal[False] = False,
-    keys: Literal[False] = False,
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None,
-    data: Literal[True],
-    keys: Literal[False] = False,
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, dict[str, Incomplete]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    *,
-    data: Literal[True],
-    keys: Literal[False] = False,
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, dict[str, Incomplete]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None,
-    data: str,
-    keys: Literal[False] = False,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
     default: _U | None = None,
 ) -> Generator[tuple[_Node, _Node, dict[str, _U]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    *,
-    data: str,
-    keys: Literal[False] = False,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
     default: _U | None = None,
 ) -> Generator[tuple[_Node, _Node, dict[str, _U]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None,
-    data: Literal[False],
-    keys: Literal[True],
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, int], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    data: Literal[False] = False,
-    *,
-    keys: Literal[True],
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, int], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None,
-    data: Literal[True],
-    keys: Literal[True],
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, int, dict[str, Incomplete]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    *,
-    data: Literal[True],
-    keys: Literal[True],
-    default=None,
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
+    default: Incomplete | None = None,
 ) -> Generator[tuple[_Node, _Node, int, dict[str, Incomplete]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None,
-    data: str,
-    keys: Literal[True],
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
     default: _U | None = None,
 ) -> Generator[tuple[_Node, _Node, int, dict[str, _U]], None, None]: ...
 @overload
 def edge_boundary(
     G: Graph[_Node],
-    nbunch1: Iterable[_Node],
-    nbunch2: Iterable[_Node] | None = None,
-    *,
-    data: str,
-    keys: Literal[True],
+    nbunch1: Iterable[Incomplete],
+    nbunch2: Iterable[Incomplete] | None = None,
+    data=False,
+    keys: bool = False,
     default: _U | None = None,
 ) -> Generator[tuple[_Node, _Node, int, dict[str, _U]], None, None]: ...
 @_dispatchable
-def node_boundary(G: Graph[_Node], nbunch1: Iterable[_Node], nbunch2: Iterable[_Node] | None = None) -> set[_Node]: ...
+def node_boundary(G: Graph[_Node], nbunch1: Iterable[Incomplete], nbunch2: Iterable[Incomplete] | None = None) -> set[_Node]: ...

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

@@ -1,6 +1,5 @@
-from _typeshed import Incomplete
-from collections.abc import Callable, Generator
-from typing import Literal, overload
+from collections.abc import Generator
+from typing import overload
 
 from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
@@ -8,12 +7,12 @@ from networkx.utils.backends import _dispatchable
 @_dispatchable
 def bridges(G: Graph[_Node], root: _Node | None = None) -> Generator[_Node, None, None]: ...
 @_dispatchable
-def has_bridges(G: Graph[_Node], root: Incomplete | None = None) -> bool: ...
+def has_bridges(G: Graph[_Node], root: _Node | None = None) -> bool: ...
 @overload
 def local_bridges(
-    G: Graph[_Node], with_span: Literal[False], weight: str | Callable[[_Node], float] | None = None
+    G: Graph[_Node], with_span: bool = True, weight: str | None = None
 ) -> Generator[tuple[_Node, _Node], None, None]: ...
 @overload
 def local_bridges(
-    G: Graph[_Node], with_span: Literal[True] = True, weight: str | Callable[[_Node], float] | None = None
+    G: Graph[_Node], with_span: bool = True, weight: str | None = None
 ) -> Generator[tuple[_Node, _Node, int], None, None]: ...

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

@@ -1,5 +1,3 @@
-from _typeshed import Incomplete
-
 from networkx.classes.graph import Graph, _Edge, _Node
 from networkx.utils.backends import _dispatchable
 from numpy.random import RandomState
@@ -8,12 +6,16 @@ from numpy.random import RandomState
 def betweenness_centrality(
     G: Graph[_Node],
     k: int | None = None,
-    normalized: bool = True,
+    normalized: bool | None = True,
     weight: str | None = None,
-    endpoints: bool = False,
+    endpoints: bool | None = False,
     seed: int | RandomState | None = None,
 ) -> dict[_Node, float]: ...
 @_dispatchable
 def edge_betweenness_centrality(
-    G: Graph[_Node], k: int | None = None, normalized: bool = True, weight: str | None = None, seed: Incomplete | None = None
+    G: Graph[_Node],
+    k: int | None = None,
+    normalized: bool | None = True,
+    weight: str | None = None,
+    seed: int | RandomState | None = None,
 ) -> dict[_Edge[_Node], float]: ...

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

@@ -5,9 +5,17 @@ from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def betweenness_centrality_subset(
-    G: Graph[_Node], sources: Iterable[_Node], targets: Iterable[_Node], normalized: bool = False, weight: str | None = None
+    G: Graph[_Node],
+    sources: Iterable[_Node],
+    targets: Iterable[_Node],
+    normalized: bool | None = False,
+    weight: str | None = None,
 ) -> dict[_Node, float]: ...
 @_dispatchable
 def edge_betweenness_centrality_subset(
-    G: Graph[_Node], sources: Iterable[_Node], targets: Iterable[_Node], normalized: bool = False, weight: str | None = None
+    G: Graph[_Node],
+    sources: Iterable[_Node],
+    targets: Iterable[_Node],
+    normalized: bool | None = False,
+    weight: str | None = None,
 ) -> dict[_Edge[_Node], float]: ...

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

@@ -1,17 +1,17 @@
-from _typeshed import SupportsKeysAndGetItem
+from _typeshed import Incomplete, SupportsGetItem
 
-from networkx.classes.graph import Graph, _Edge, _Node
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def closeness_centrality(
-    G: Graph[_Node], u: _Node | None = None, distance: str | None = None, wf_improved: bool = True
+    G: Graph[_Node], u: _Node | None = None, distance=None, wf_improved: bool | None = True
 ) -> dict[_Node, float]: ...
 @_dispatchable
 def incremental_closeness_centrality(
     G: Graph[_Node],
-    edge: _Edge[_Node],
-    prev_cc: SupportsKeysAndGetItem[_Node, float] | None = None,
-    insertion: bool = True,
-    wf_improved: bool = True,
+    edge: tuple[Incomplete],
+    prev_cc: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    insertion: bool | None = True,
+    wf_improved: bool | None = True,
 ) -> dict[_Node, float]: ...

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

@@ -1,23 +1,23 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
+from numpy.random import RandomState
 
 @_dispatchable
 def approximate_current_flow_betweenness_centrality(
-    G,
-    normalized: bool = True,
-    weight: Incomplete | None = None,
-    dtype=...,
+    G: Graph[_Node],
+    normalized: bool | None = True,
+    weight: str | None = None,
+    dtype: type = ...,
     solver: str = "full",
     epsilon: float = 0.5,
     kmax: int = 10000,
-    seed: Incomplete | None = None,
+    seed: int | RandomState | None = None,
 ): ...
 @_dispatchable
 def current_flow_betweenness_centrality(
-    G, normalized: bool = True, weight: Incomplete | None = None, dtype=..., solver: str = "full"
+    G: Graph[_Node], normalized: bool | None = True, weight: str | None = None, dtype: type = ..., solver: str = "full"
 ): ...
 @_dispatchable
 def edge_current_flow_betweenness_centrality(
-    G, normalized: bool = True, weight: Incomplete | None = None, dtype=..., solver: str = "full"
+    G: Graph[_Node], normalized: bool | None = True, weight: str | None = None, dtype: type = ..., solver: str = "full"
 ): ...

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

@@ -1,12 +1,25 @@
-from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def current_flow_betweenness_centrality_subset(
-    G, sources, targets, normalized: bool = True, weight: Incomplete | None = None, dtype=..., solver: str = "lu"
+    G: Graph[_Node],
+    sources: Iterable[_Node],
+    targets: Iterable[_Node],
+    normalized: bool | None = True,
+    weight: str | None = None,
+    dtype: type = ...,
+    solver: str = "lu",
 ): ...
 @_dispatchable
 def edge_current_flow_betweenness_centrality_subset(
-    G, sources, targets, normalized: bool = True, weight: Incomplete | None = None, dtype=..., solver: str = "lu"
+    G: Graph[_Node],
+    sources: Iterable[_Node],
+    targets: Iterable[_Node],
+    normalized: bool | None = True,
+    weight: str | None = None,
+    dtype: type = ...,
+    solver: str = "lu",
 ): ...

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

@@ -1,8 +1,7 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def current_flow_closeness_centrality(G, weight: Incomplete | None = None, dtype=..., solver: str = "lu"): ...
+def current_flow_closeness_centrality(G: Graph[_Node], weight: str | None = None, dtype: type = ..., solver: str = "lu"): ...
 
 information_centrality = current_flow_closeness_centrality

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

@@ -1,10 +1,17 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def eigenvector_centrality(
-    G, max_iter: int = 100, tol: float = 1e-06, nstart: Incomplete | None = None, weight: Incomplete | None = None
+    G: Graph[_Node],
+    max_iter: int | None = 100,
+    tol: float | None = 1e-06,
+    nstart: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    weight: str | None = None,
 ): ...
 @_dispatchable
-def eigenvector_centrality_numpy(G, weight: Incomplete | None = None, max_iter: int = 50, tol: float = 0): ...
+def eigenvector_centrality_numpy(
+    G: Graph[_Node], weight: str | None = None, max_iter: int | None = 50, tol: float | None = 0
+): ...

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

@@ -12,6 +12,7 @@ class InverseLaplacian:
     w: Incomplete
     C: Incomplete
     L1: Incomplete
+
     def __init__(self, L, width: Incomplete | None = None, dtype: Incomplete | None = None) -> None: ...
     def init_solver(self, L) -> None: ...
     def solve(self, r) -> None: ...
@@ -22,18 +23,21 @@ class InverseLaplacian:
 
 class FullInverseLaplacian(InverseLaplacian):
     IL: Incomplete
+
     def init_solver(self, L) -> None: ...
     def solve(self, rhs): ...
     def solve_inverse(self, r): ...
 
 class SuperLUInverseLaplacian(InverseLaplacian):
     lusolve: Incomplete
+
     def init_solver(self, L) -> None: ...
     def solve_inverse(self, r): ...
     def solve(self, rhs): ...
 
 class CGInverseLaplacian(InverseLaplacian):
     M: Incomplete
+
     def init_solver(self, L) -> None: ...
     def solve(self, rhs): ...
     def solve_inverse(self, r): ...

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

@@ -1,24 +1,28 @@
 from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def group_betweenness_centrality(G, C, normalized: bool = True, weight: Incomplete | None = None, endpoints: bool = False): ...
+def group_betweenness_centrality(
+    G: Graph[_Node], C, normalized: bool | None = True, weight: str | None = None, endpoints: bool | None = False
+): ...
 @_dispatchable
 def prominent_group(
-    G,
-    k,
-    weight: Incomplete | None = None,
-    C: Incomplete | None = None,
-    endpoints: bool = False,
-    normalized: bool = True,
-    greedy: bool = False,
+    G: Graph[_Node],
+    k: int,
+    weight: str | None = None,
+    C: Iterable[Incomplete] | None = None,
+    endpoints: bool | None = False,
+    normalized: bool | None = True,
+    greedy: bool | None = False,
 ): ...
 @_dispatchable
-def group_closeness_centrality(G, S, weight: Incomplete | None = None): ...
+def group_closeness_centrality(G: Graph[_Node], S: Iterable[Incomplete], weight: str | None = None): ...
 @_dispatchable
-def group_degree_centrality(G, S): ...
+def group_degree_centrality(G: Graph[_Node], S: Iterable[Incomplete]): ...
 @_dispatchable
-def group_in_degree_centrality(G, S): ...
+def group_in_degree_centrality(G: Graph[_Node], S: Iterable[Incomplete]): ...
 @_dispatchable
-def group_out_degree_centrality(G, S): ...
+def group_out_degree_centrality(G: Graph[_Node], S: Iterable[Incomplete]): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/centrality/harmonic.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 harmonic_centrality(
-    G, nbunch: Incomplete | None = None, distance: Incomplete | None = None, sources: Incomplete | None = None
+    G: Graph[_Node], nbunch: Iterable[Incomplete] | None = None, distance=None, sources: Iterable[Incomplete] | None = None
 ): ...

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

@@ -1,19 +1,24 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def katz_centrality(
-    G,
-    alpha: float = 0.1,
-    beta: float = 1.0,
-    max_iter: int = 1000,
-    tol: float = 1e-06,
-    nstart: Incomplete | None = None,
-    normalized: bool = True,
-    weight: Incomplete | None = None,
+    G: Graph[_Node],
+    alpha: float | None = 0.1,
+    beta: float | SupportsGetItem[Incomplete, Incomplete] | None = 1.0,
+    max_iter: int | None = 1000,
+    tol: float | None = 1e-06,
+    nstart: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    normalized: bool | None = True,
+    weight: str | None = None,
 ): ...
 @_dispatchable
 def katz_centrality_numpy(
-    G, alpha: float = 0.1, beta: float = 1.0, normalized: bool = True, weight: Incomplete | None = None
+    G: Graph[_Node],
+    alpha: float = 0.1,
+    beta: float | SupportsGetItem[Incomplete, Incomplete] | None = 1.0,
+    normalized: bool = True,
+    weight: str | None = None,
 ): ...

package/dist/typeshed-fallback/stubs/networkx/networkx/algorithms/centrality/laplacian.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 laplacian_centrality(
-    G,
+    G: Graph[_Node],
     normalized: bool = True,
-    nodelist: Incomplete | None = None,
-    weight: str = "weight",
-    walk_type: Incomplete | None = None,
+    nodelist: Iterable[Incomplete] | None = None,
+    weight: str | None = "weight",
+    walk_type: str | None = None,
     alpha: float = 0.95,
 ): ...

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

@@ -1,15 +1,14 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 __all__ = ["load_centrality", "edge_load_centrality"]
 
 @_dispatchable
 def newman_betweenness_centrality(
-    G, v: Incomplete | None = None, cutoff: Incomplete | None = None, normalized: bool = True, weight: Incomplete | None = None
+    G: Graph[_Node], v=None, cutoff: bool | None = None, normalized: bool | None = True, weight: str | None = None
 ): ...
 
 load_centrality = newman_betweenness_centrality
 
 @_dispatchable
-def edge_load_centrality(G, cutoff: bool = False): ...
+def edge_load_centrality(G: Graph[_Node], cutoff: bool | None = False): ...

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

@@ -1,8 +1,12 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
 def percolation_centrality(
-    G, attribute: str = "percolation", states: Incomplete | None = None, weight: Incomplete | None = None
+    G: Graph[_Node],
+    attribute: str | None = "percolation",
+    states: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    weight: str | None = None,
 ): ...

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

@@ -1,10 +1,16 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, SupportsGetItem
 
+from networkx.classes.digraph import DiGraph
+from networkx.classes.graph import _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def global_reaching_centrality(G, weight: Incomplete | None = None, normalized: bool = True): ...
+def global_reaching_centrality(G: DiGraph[_Node], weight: str | None = None, normalized: bool | None = True): ...
 @_dispatchable
 def local_reaching_centrality(
-    G, v, paths: Incomplete | None = None, weight: Incomplete | None = None, normalized: bool = True
+    G: DiGraph[_Node],
+    v: _Node,
+    paths: SupportsGetItem[Incomplete, Incomplete] | None = None,
+    weight: str | None = None,
+    normalized: bool | None = True,
 ): ...

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

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

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

@@ -1,10 +1,11 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def subgraph_centrality_exp(G): ...
+def subgraph_centrality_exp(G: Graph[_Node]): ...
 @_dispatchable
-def subgraph_centrality(G): ...
+def subgraph_centrality(G: Graph[_Node]): ...
 @_dispatchable
-def communicability_betweenness_centrality(G): ...
+def communicability_betweenness_centrality(G: Graph[_Node]): ...
 @_dispatchable
-def estrada_index(G): ...
+def estrada_index(G: Graph[_Node]): ...

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

@@ -1,8 +1,10 @@
+from networkx.classes.digraph import DiGraph
+from networkx.classes.graph import _Node
 from networkx.utils.backends import _dispatchable
 
 @_dispatchable
-def trophic_levels(G, weight: str = "weight"): ...
+def trophic_levels(G: DiGraph[_Node], weight="weight"): ...
 @_dispatchable
-def trophic_differences(G, weight: str = "weight"): ...
+def trophic_differences(G: DiGraph[_Node], weight="weight"): ...
 @_dispatchable
-def trophic_incoherence_parameter(G, weight: str = "weight", cannibalism: bool = False): ...
+def trophic_incoherence_parameter(G: DiGraph[_Node], weight="weight", cannibalism: bool = False): ...

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

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

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

@@ -1,5 +1,5 @@
 import sys
-from collections.abc import Generator, Hashable
+from collections.abc import Generator
 
 from networkx.classes.graph import Graph, _Node
 from networkx.exception import NetworkXException
@@ -8,10 +8,10 @@ from networkx.utils.backends import _dispatchable
 class NetworkXTreewidthBoundExceeded(NetworkXException): ...
 
 @_dispatchable
-def is_chordal(G: Graph[Hashable]) -> bool: ...
+def is_chordal(G: Graph[_Node]) -> bool: ...
 @_dispatchable
 def find_induced_nodes(G: Graph[_Node], s: _Node, t: _Node, treewidth_bound: float = sys.maxsize) -> set[_Node]: ...
 @_dispatchable
 def chordal_graph_cliques(G: Graph[_Node]) -> Generator[frozenset[_Node], None, None]: ...
 @_dispatchable
-def chordal_graph_treewidth(G: Graph[Hashable]) -> int: ...
+def chordal_graph_treewidth(G: Graph[_Node]) -> int: ...