basedpyright 1.10.3 → 1.10.4

package/dist/typeshed-fallback/stubs/icalendar/icalendar/cal.pyi

@@ -0,0 +1,86 @@
+from _typeshed import Incomplete, SupportsItems
+from typing import Any, ClassVar, Final, Literal, overload
+
+from pytz.tzinfo import DstTzInfo
+
+from .caselessdict import CaselessDict
+from .parser import Contentline, Contentlines
+from .prop import TypesFactory
+
+class ComponentFactory(CaselessDict[Incomplete]):
+    def __init__(self, *args, **kwargs) -> None: ...
+
+INLINE: CaselessDict[int]
+
+class Component(CaselessDict[Incomplete]):
+    name: ClassVar[str | None]
+    required: ClassVar[tuple[str, ...]]
+    singletons: ClassVar[tuple[str, ...]]
+    multiple: ClassVar[tuple[str, ...]]
+    exclusive: ClassVar[tuple[str, ...]]
+    inclusive: ClassVar[tuple[tuple[str, ...], ...]]
+    ignore_exceptions: ClassVar[bool]
+    subcomponents: list[Incomplete]
+    errors: list[str]
+
+    def __init__(self, *args, **kwargs) -> None: ...
+    def __bool__(self) -> bool: ...
+    __nonzero__ = __bool__
+    def is_empty(self) -> bool: ...
+    @property
+    def is_broken(self) -> bool: ...
+    @overload
+    def add(self, name: str, value: Any, *, encode: Literal[False]) -> None: ...
+    @overload
+    def add(self, name: str, value: Any, parameters: None, encode: Literal[False]) -> None: ...
+    @overload
+    def add(
+        self, name: str, value: Any, parameters: SupportsItems[str, str | None] | None = None, encode: Literal[True] = True
+    ) -> None: ...
+    def decoded(self, name, default=[]): ...
+    def get_inline(self, name, decode: bool = True): ...
+    def set_inline(self, name, values, encode: bool = True) -> None: ...
+    def add_component(self, component: Component) -> None: ...
+    def walk(self, name: Incomplete | None = None): ...
+    def property_items(self, recursive: bool = True, sorted: bool = True): ...
+    @overload
+    @classmethod
+    def from_ical(cls, st: str, multiple: Literal[False] = False) -> Component: ...  # or any of its subclasses
+    @overload
+    @classmethod
+    def from_ical(cls, st: str, multiple: Literal[True]) -> list[Component]: ...  # or any of its subclasses
+    def content_line(self, name: str, value, sorted: bool = True) -> Contentline: ...
+    def content_lines(self, sorted: bool = True) -> Contentlines: ...
+    def to_ical(self, sorted: bool = True) -> bytes: ...
+    def __eq__(self, other: Component) -> bool: ...  # type: ignore[override]
+
+class Event(Component):
+    name: ClassVar[Literal["VEVENT"]]
+
+class Todo(Component):
+    name: ClassVar[Literal["VTODO"]]
+
+class Journal(Component):
+    name: ClassVar[Literal["VJOURNAL"]]
+
+class FreeBusy(Component):
+    name: ClassVar[Literal["VFREEBUSY"]]
+
+class Timezone(Component):
+    name: ClassVar[Literal["VTIMEZONE"]]
+    def to_tz(self) -> DstTzInfo: ...
+
+class TimezoneStandard(Component):
+    name: ClassVar[Literal["STANDARD"]]
+
+class TimezoneDaylight(Component):
+    name: ClassVar[Literal["DAYLIGHT"]]
+
+class Alarm(Component):
+    name: ClassVar[Literal["VALARM"]]
+
+class Calendar(Component):
+    name: ClassVar[Literal["VCALENDAR"]]
+
+types_factory: Final[TypesFactory]
+component_factory: Final[ComponentFactory]

package/dist/typeshed-fallback/stubs/icalendar/icalendar/caselessdict.pyi

@@ -0,0 +1,43 @@
+from _typeshed import SupportsItems
+from collections import OrderedDict
+from collections.abc import Iterable, Mapping
+from typing import ClassVar, TypeVar, overload
+from typing_extensions import Self
+
+_T = TypeVar("_T")
+_VT = TypeVar("_VT")
+
+def canonsort_keys(keys: Iterable[str], canonical_order: Iterable[str] | None = None) -> list[str]: ...
+def canonsort_items(dict1: Mapping[str, _VT], canonical_order: Iterable[str] | None = None) -> list[tuple[str, _VT]]: ...
+
+class CaselessDict(OrderedDict[str, _VT]):
+    # Inherit complex __init__ from dict.
+    def __getitem__(self, key: str | bytes) -> _VT: ...
+    def __setitem__(self, key: str | bytes, value: _VT) -> None: ...
+    def __delitem__(self, key: str | bytes) -> None: ...
+    def __contains__(self, key: str | bytes) -> bool: ...  # type: ignore[override]
+    @overload
+    def get(self, key: str | bytes, default: None = None) -> _VT: ...
+    @overload
+    def get(self, key: str | bytes, default: _VT) -> _VT: ...
+    @overload
+    def get(self, key: str | bytes, default: _T) -> _VT | _T: ...
+    @overload
+    def setdefault(self: CaselessDict[_T | None], key: str | bytes, value: None = None) -> _T | None: ...
+    @overload
+    def setdefault(self, key: str | bytes, value: _VT) -> _VT: ...
+    @overload  # type: ignore[override]
+    def pop(self, key: str | bytes, default: None = None) -> _VT | None: ...
+    @overload
+    def pop(self, key: str | bytes, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: str | bytes, default: _T) -> _VT | _T: ...
+    def popitem(self) -> tuple[str, _VT]: ...  # type: ignore[override]
+    def has_key(self, key: str | bytes) -> bool: ...
+    def update(self, *args: SupportsItems[str, _VT] | Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ...  # type: ignore[override]
+    def copy(self) -> Self: ...
+    def __eq__(self, other: SupportsItems[str, _VT]) -> bool: ...  # type: ignore[override]
+    def __ne__(self, other: SupportsItems[str, _VT]) -> bool: ...  # type: ignore[override]
+    canonical_order: ClassVar[Iterable[str] | None]
+    def sorted_keys(self) -> list[str]: ...
+    def sorted_items(self) -> list[tuple[str, _VT]]: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/parser.pyi

@@ -0,0 +1,58 @@
+from _collections_abc import dict_keys
+from _typeshed import Incomplete
+from collections.abc import Iterable
+from re import Pattern
+from typing import AnyStr, Final, overload
+from typing_extensions import Self
+
+from .caselessdict import CaselessDict
+
+def escape_char(text: str) -> str: ...
+def unescape_char(text: AnyStr) -> AnyStr: ...
+def tzid_from_dt(dt): ...
+def foldline(line: str, limit: int = 75, fold_sep: str = "\r\n ") -> str: ...
+def param_value(value: str | list[str] | tuple[str, ...] | Incomplete) -> str: ...
+
+NAME: Final[Pattern[str]]
+UNSAFE_CHAR: Final[Pattern[str]]
+QUNSAFE_CHAR: Final[Pattern[str]]
+FOLD: Final[Pattern[bytes]]
+uFOLD: Final[Pattern[str]]
+NEWLINE: Final[Pattern[str]]
+
+def validate_token(name: str) -> None: ...
+def validate_param_value(value: str, quoted: bool = True) -> None: ...
+
+QUOTABLE: Final[Pattern[str]]
+
+def dquote(val: str) -> str: ...
+def q_split(st: str, sep: str = ",", maxsplit: int = -1) -> list[str]: ...
+def q_join(lst: Iterable[str], sep: str = ",") -> str: ...
+
+class Parameters(CaselessDict[str]):
+    def params(self) -> dict_keys[str, str]: ...
+    def to_ical(self, sorted: bool = True) -> bytes: ...
+    @classmethod
+    def from_ical(cls, st: str, strict: bool = False) -> Self: ...
+
+def escape_string(val: str) -> str: ...
+def unescape_string(val: str) -> str: ...
+@overload
+def unescape_list_or_string(val: list[str]) -> list[str]: ...
+@overload
+def unescape_list_or_string(val: str) -> str: ...
+
+class Contentline(str):
+    strict: bool
+    def __new__(cls, value: str | bytes, strict: bool = False, encoding: str = ...) -> Self: ...
+    @classmethod
+    def from_parts(cls, name: str, params: Parameters, values, sorted: bool = True) -> Self: ...
+    def parts(self) -> tuple[str, Parameters, str]: ...
+    @classmethod
+    def from_ical(cls, ical: str | bytes, strict: bool = False) -> Self: ...
+    def to_ical(self) -> bytes: ...
+
+class Contentlines(list[Contentline]):
+    def to_ical(self) -> bytes: ...
+    @classmethod
+    def from_ical(cls, st: str | bytes) -> Self: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/parser_tools.pyi

@@ -0,0 +1,17 @@
+from typing import Any, Final, TypeVar, overload
+
+_T = TypeVar("_T")
+
+SEQUENCE_TYPES: Final[tuple[type[Any], ...]]
+DEFAULT_ENCODING: str
+
+def from_unicode(value: str | bytes, encoding: str = "utf-8") -> bytes: ...
+def to_unicode(value: str | bytes, encoding: str = "utf-8") -> str: ...
+@overload
+def data_encode(data: str, encoding: str = ...) -> bytes: ...  # type: ignore[misc]
+@overload
+def data_encode(data: dict[Any, Any], encoding: str = ...) -> dict[Any, Any]: ...
+@overload
+def data_encode(data: list[Any] | tuple[Any, ...], encoding: str = ...) -> list[Any]: ...  # type: ignore[misc]
+@overload
+def data_encode(data: _T, encoding: str = ...) -> _T: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/prop.pyi

@@ -0,0 +1,225 @@
+import datetime
+from _typeshed import Incomplete
+from datetime import tzinfo
+from re import Pattern
+from typing import Any, ClassVar, Final
+from typing_extensions import TypeAlias
+
+from .caselessdict import CaselessDict
+from .parser import Parameters
+
+_PropType: TypeAlias = type[Any]  # any of the v* classes in this file
+
+DURATION_REGEX: Final[Pattern[str]]
+WEEKDAY_RULE: Final[Pattern[str]]
+ZERO: Final[datetime.timedelta]
+HOUR: Final[datetime.timedelta]
+STDOFFSET: Final[datetime.timedelta]
+DSTOFFSET: Final[datetime.timedelta]
+DSTDIFF: Final[datetime.timedelta]
+
+class FixedOffset(tzinfo):
+    def __init__(self, offset, name) -> None: ...
+    def utcoffset(self, dt): ...
+    def tzname(self, dt): ...
+    def dst(self, dt): ...
+
+class LocalTimezone(tzinfo):
+    def utcoffset(self, dt): ...
+    def dst(self, dt): ...
+    def tzname(self, dt): ...
+
+class vBinary:
+    obj: Incomplete
+    params: Incomplete
+    def __init__(self, obj) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+    def __eq__(self, other): ...
+
+class vBoolean(int):
+    BOOL_MAP: Incomplete
+    params: Incomplete
+    def __new__(cls, *args, **kwargs): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vCalAddress(str):
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vFloat(float):
+    params: Incomplete
+    def __new__(cls, *args, **kwargs): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vInt(int):
+    params: Incomplete
+    def __new__(cls, *args, **kwargs): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vDDDLists:
+    params: Incomplete
+    dts: Incomplete
+    def __init__(self, dt_list) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical, timezone: Incomplete | None = None): ...
+    def __eq__(self, other): ...
+
+class vCategory:
+    cats: Incomplete
+    params: Incomplete
+    def __init__(self, c_list) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+    def __eq__(self, other): ...
+
+class TimeBase:
+    def __eq__(self, other): ...
+    def __hash__(self): ...
+
+class vDDDTypes(TimeBase):
+    params: Incomplete
+    dt: Incomplete
+    def __init__(self, dt) -> None: ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical, timezone: Incomplete | None = None): ...
+
+class vDate(TimeBase):
+    dt: Incomplete
+    params: Incomplete
+    def __init__(self, dt) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+
+class vDatetime(TimeBase):
+    dt: Incomplete
+    params: Incomplete
+    def __init__(self, dt) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical, timezone: Incomplete | None = None): ...
+
+class vDuration(TimeBase):
+    td: Incomplete
+    params: Incomplete
+    def __init__(self, td) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+    @property
+    def dt(self): ...
+
+class vPeriod(TimeBase):
+    params: Incomplete
+    start: Incomplete
+    end: Incomplete
+    by_duration: Incomplete
+    duration: Incomplete
+    def __init__(self, per) -> None: ...
+    def overlaps(self, other): ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical, timezone: Incomplete | None = None): ...
+    @property
+    def dt(self): ...
+
+class vWeekday(str):
+    week_days: Incomplete
+    relative: Incomplete
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vFrequency(str):
+    frequencies: Incomplete
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vRecur(CaselessDict[Incomplete]):
+    frequencies: ClassVar[list[str]]
+    canonical_order: ClassVar[tuple[str, ...]]
+    types: ClassVar[CaselessDict[_PropType]]
+    params: Parameters
+    def __init__(self, *args, **kwargs) -> None: ...
+    def to_ical(self): ...
+    @classmethod
+    def parse_type(cls, key, values): ...
+    @classmethod
+    def from_ical(cls, ical) -> dict[str, Incomplete]: ...
+
+class vText(str):
+    encoding: Incomplete
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vTime(TimeBase):
+    dt: Incomplete
+    params: Incomplete
+    def __init__(self, *args) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+
+class vUri(str):
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class vGeo:
+    latitude: Incomplete
+    longitude: Incomplete
+    params: Incomplete
+    def __init__(self, geo) -> None: ...
+    def to_ical(self): ...
+    @staticmethod
+    def from_ical(ical): ...
+    def __eq__(self, other): ...
+
+class vUTCOffset:
+    ignore_exceptions: bool
+    td: Incomplete
+    params: Incomplete
+    def __init__(self, td) -> None: ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+    def __eq__(self, other): ...
+
+class vInline(str):
+    params: Incomplete
+    def __new__(cls, value, encoding="utf-8"): ...
+    def to_ical(self): ...
+    @classmethod
+    def from_ical(cls, ical): ...
+
+class TypesFactory(CaselessDict[_PropType]):
+    all_types: tuple[_PropType, ...]
+    def __init__(self, *args, **kwargs) -> None: ...
+    types_map: CaselessDict[str]
+    def for_property(self, name: str) -> _PropType: ...
+    def to_ical(self, name: str, value) -> bytes: ...
+    def from_ical(self, name: str, value): ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/tools.pyi

@@ -0,0 +1,10 @@
+from typing import Final
+
+from .prop import vText
+
+class UIDGenerator:
+    chars: Final[list[str]]
+    @staticmethod
+    def rnd_string(length: int = 16) -> str: ...
+    @staticmethod
+    def uid(host_name: str = "example.com", unique: str = "") -> vText: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/windows_to_olson.pyi

@@ -0,0 +1,3 @@
+from typing import Final
+
+WINDOWS_TO_OLSON: Final[dict[str, str]]

package/dist/typeshed-fallback/stubs/influxdb-client/METADATA.toml

@@ -1,4 +1,4 @@
-version = "1.41.*"
+version = "1.42.*"
 upstream_repository = "https://github.com/influxdata/influxdb-client-python"
 # requires a version of urllib3 with a py.typed file
 requires = ["urllib3>=2"]

package/dist/typeshed-fallback/stubs/influxdb-client/influxdb_client/client/flux_csv_parser.pyi

@@ -19,13 +19,13 @@ class FluxQueryException(Exception):
 class FluxCsvParserException(Exception): ...
 
 class FluxSerializationMode(Enum):
-    tables: int
-    stream: int
-    dataFrame: int
+    tables = 1
+    stream = 2
+    dataFrame = 3
 
 class FluxResponseMetadataMode(Enum):
-    full: int
-    only_names: int
+    full = 1
+    only_names = 2
 
 class _FluxCsvParserMetadata:
     table_index: int

package/dist/typeshed-fallback/stubs/influxdb-client/influxdb_client/client/write_api.pyi

@@ -17,9 +17,9 @@ _Observable: TypeAlias = Any  # reactivex.Observable
 logger: logging.Logger
 
 class WriteType(Enum):
-    batching: int
-    asynchronous: int
-    synchronous: int
+    batching = 1
+    asynchronous = 2
+    synchronous = 3
 
 class WriteOptions:
     write_type: WriteType

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

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

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

@@ -1,8 +1,13 @@
-from _typeshed import Incomplete
+from collections.abc import Iterable
 
+from networkx.classes.graph import Graph, _Edge, _Node
 from networkx.utils.backends import _dispatch
 
 @_dispatch
-def betweenness_centrality_subset(G, sources, targets, normalized: bool = False, weight: Incomplete | None = None): ...
+def betweenness_centrality_subset(
+    G: Graph[_Node], sources: Iterable[_Node], targets: Iterable[_Node], normalized: bool = False, weight: str | None = None
+) -> dict[_Node, float]: ...
 @_dispatch
-def edge_betweenness_centrality_subset(G, sources, targets, normalized: bool = False, weight: Incomplete | None = None): ...
+def edge_betweenness_centrality_subset(
+    G: Graph[_Node], sources: Iterable[_Node], targets: Iterable[_Node], normalized: bool = False, weight: str | None = None
+) -> dict[_Edge[_Node], float]: ...

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

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

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

@@ -1,8 +1,9 @@
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatch
 
 @_dispatch
-def degree_centrality(G): ...
+def degree_centrality(G: Graph[_Node]) -> dict[_Node, float]: ...
 @_dispatch
-def in_degree_centrality(G): ...
+def in_degree_centrality(G: Graph[_Node]) -> dict[_Node, float]: ...
 @_dispatch
-def out_degree_centrality(G): ...
+def out_degree_centrality(G: Graph[_Node]) -> dict[_Node, float]: ...

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

@@ -1,14 +1,13 @@
-from _typeshed import Incomplete
-
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatch
 
 @_dispatch
 def dispersion(
-    G,
-    u: Incomplete | None = None,
-    v: Incomplete | None = None,
+    G: Graph[_Node],
+    u: _Node | None = None,
+    v: _Node | None = None,
     normalized: bool = True,
     alpha: float = 1.0,
     b: float = 0.0,
     c: float = 0.0,
-): ...
+) -> dict[_Node, float] | dict[_Node, dict[_Node, float]]: ...

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

@@ -20,11 +20,11 @@ def to_networkx_graph(
 @_dispatch
 def to_dict_of_lists(G: Graph[_Node], nodelist: None | Iterable[_Node] = None) -> dict[_Node, list[_Node]]: ...
 @_dispatch
-def from_dict_of_lists(d: dict[_Node, Iterable[_Node]], create_using: Incomplete | None = None): ...
-def to_dict_of_dicts(G, nodelist=None, edge_data=None) -> dict[Incomplete, Incomplete]: ...
+def from_dict_of_lists(d: dict[_Node, Iterable[_Node]], create_using: Incomplete | None = None) -> Graph[_Node]: ...
+def to_dict_of_dicts(G: Graph[_Node], nodelist=None, edge_data=None) -> dict[Incomplete, Incomplete]: ...
 @_dispatch
-def from_dict_of_dicts(d, create_using=None, multigraph_input=False): ...
+def from_dict_of_dicts(d, create_using=None, multigraph_input=False) -> Graph[Incomplete]: ...
 @_dispatch
-def to_edgelist(G, nodelist=None): ...
+def to_edgelist(G: Graph[_Node], nodelist=None): ...
 @_dispatch
-def from_edgelist(edgelist, create_using=None): ...
+def from_edgelist(edgelist, create_using=None) -> Graph[Incomplete]: ...

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

@@ -87,10 +87,15 @@ class Worksheet(_WorkbookChild):
     @freeze_panes.setter
     def freeze_panes(self, topLeftCell: str | Cell | None = ...) -> None: ...
     def cell(self, row: int, column: int, value: str | None = None) -> Cell: ...
+    # An int is necessarily a row selection
     @overload
-    def __getitem__(self, key: int | slice) -> tuple[Cell, ...]: ...
+    def __getitem__(self, key: int) -> tuple[Cell, ...]: ...
+    # A slice is necessarily a row or rows, even if targetting a single cell
     @overload
-    def __getitem__(self, key: str) -> Any: ...  # AnyOf[Cell, tuple[Cell, ...]]
+    def __getitem__(self, key: slice) -> tuple[Any, ...]: ...  # tuple[AnyOf[Cell, tuple[Cell, ...]]]
+    # A str could be an individual cell, row, column or full range
+    @overload
+    def __getitem__(self, key: str) -> Any: ...  # AnyOf[Cell, tuple[Cell, ...], tuple[tuple[Cell, ...], ...]]
     def __setitem__(self, key: str, value: str) -> None: ...
     def __iter__(self) -> Iterator[tuple[Cell, ...]]: ...
     def __delitem__(self, key: str) -> None: ...

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

@@ -1,3 +1,4 @@
+from _typeshed import FileDescriptorOrPath
 from collections.abc import Iterable, Mapping
 from typing import NoReturn, Protocol
 
@@ -22,9 +23,9 @@ class _TransportFactory(Protocol):
 
 class SSHClient(ClosingContextManager):
     def __init__(self) -> None: ...
-    def load_system_host_keys(self, filename: str | None = None) -> None: ...
-    def load_host_keys(self, filename: str) -> None: ...
-    def save_host_keys(self, filename: str) -> None: ...
+    def load_system_host_keys(self, filename: FileDescriptorOrPath | None = None) -> None: ...
+    def load_host_keys(self, filename: FileDescriptorOrPath) -> None: ...
+    def save_host_keys(self, filename: FileDescriptorOrPath) -> None: ...
     def get_host_keys(self) -> HostKeys: ...
     def set_log_channel(self, name: str) -> None: ...
     def set_missing_host_key_policy(self, policy: type[MissingHostKeyPolicy] | MissingHostKeyPolicy) -> None: ...

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

@@ -1,3 +1,4 @@
+from _typeshed import FileDescriptorOrPath
 from collections.abc import Iterable
 from re import Pattern
 from typing import IO
@@ -14,7 +15,7 @@ class SSHConfig:
     @classmethod
     def from_text(cls, text: str) -> Self: ...
     @classmethod
-    def from_path(cls, path: str) -> Self: ...
+    def from_path(cls, path: FileDescriptorOrPath) -> Self: ...
     @classmethod
     def from_file(cls, flo: IO[str]) -> Self: ...
     def parse(self, file_obj: IO[str]) -> None: ...