basedpyright 1.13.1 → 1.13.2

package/dist/typeshed-fallback/commit.txt

@@ -1 +1 @@
-58f2a795bac5924367d21961af53a32af7bb5727
+82199768bf2e651804cb718f4b570af6d41333d9

package/dist/typeshed-fallback/stdlib/VERSIONS

@@ -34,6 +34,7 @@ _dummy_thread: 3.0-3.8
 _dummy_threading: 3.0-3.8
 _heapq: 3.0-
 _imp: 3.0-
+_interpchannels: 3.13-
 _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-
@@ -65,9 +66,9 @@ array: 3.0-
 ast: 3.0-
 asynchat: 3.0-3.11
 asyncio: 3.4-
-asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
 asyncio.format_helpers: 3.7-
+asyncio.mixins: 3.10-
 asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
@@ -270,6 +271,7 @@ threading: 3.0-
 time: 3.0-
 timeit: 3.0-
 tkinter: 3.0-
+tkinter.tix: 3.0-3.12
 token: 3.0-
 tokenize: 3.0-
 tomllib: 3.11-

package/dist/typeshed-fallback/stdlib/_ast.pyi

@@ -11,7 +11,7 @@ if sys.version_info >= (3, 13):
     PyCF_OPTIMIZED_AST: Literal[33792]
 
 # Used for node end positions in constructor keyword arguments
-_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)  # noqa: Y023
+_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)
 
 # Alias used for fields that must always be valid identifiers
 # A string `x` counts as a valid identifier if both the following are True

package/dist/typeshed-fallback/stdlib/_bisect.pyi

@@ -1,221 +1,221 @@
-"""
-Bisection algorithms.
-
-This module provides support for maintaining a list in sorted order without
-having to sort the list after each insertion. For long lists of items with
-expensive comparison operations, this can be an improvement over the more
-common approach.
-"""
-
-import sys
-from _typeshed import SupportsLenAndGetItem, SupportsRichComparisonT
-from collections.abc import Callable, MutableSequence
-from typing import TypeVar, overload
-
-_T = TypeVar("_T")
-
-if sys.version_info >= (3, 10):
-    @overload
-    def bisect_left(
-        a: SupportsLenAndGetItem[SupportsRichComparisonT],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: None = None,
-    ) -> int:
-        """
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e < x, and all e in
-        a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
-        insert just before the leftmost x already there.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def bisect_left(
-        a: SupportsLenAndGetItem[_T],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: Callable[[_T], SupportsRichComparisonT],
-    ) -> int:
-        """
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e < x, and all e in
-        a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
-        insert just before the leftmost x already there.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def bisect_right(
-        a: SupportsLenAndGetItem[SupportsRichComparisonT],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: None = None,
-    ) -> int:
-        """
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e <= x, and all e in
-        a[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will
-        insert just after the rightmost x already there.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def bisect_right(
-        a: SupportsLenAndGetItem[_T],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: Callable[[_T], SupportsRichComparisonT],
-    ) -> int:
-        """
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e <= x, and all e in
-        a[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will
-        insert just after the rightmost x already there.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def insort_left(
-        a: MutableSequence[SupportsRichComparisonT],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: None = None,
-    ) -> None:
-        """
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the left of the leftmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def insort_left(
-        a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
-    ) -> None:
-        """
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the left of the leftmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def insort_right(
-        a: MutableSequence[SupportsRichComparisonT],
-        x: SupportsRichComparisonT,
-        lo: int = 0,
-        hi: int | None = None,
-        *,
-        key: None = None,
-    ) -> None:
-        """
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the right of the rightmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    @overload
-    def insort_right(
-        a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
-    ) -> None:
-        """
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the right of the rightmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-
-else:
-    def bisect_left(
-        a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> int:
-        """
-        bisect_left(a, x[, lo[, hi]]) -> index
-
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e < x, and all e in
-        a[i:] have e >= x.  So if x already appears in the list, i points just
-        before the leftmost x already there.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    def bisect_right(
-        a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> int:
-        """
-        bisect_right(a, x[, lo[, hi]]) -> index
-
-        Return the index where to insert item x in list a, assuming a is sorted.
-
-        The return value i is such that all e in a[:i] have e <= x, and all e in
-        a[i:] have e > x.  So if x already appears in the list, i points just
-        beyond the rightmost x already there
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    def insort_left(
-        a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> None:
-        """
-        insort_left(a, x[, lo[, hi]])
-
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the left of the leftmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
-    def insort_right(
-        a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
-    ) -> None:
-        """
-        insort_right(a, x[, lo[, hi]])
-
-        Insert item x in list a, and keep it sorted assuming a is sorted.
-
-        If x is already in a, insert it to the right of the rightmost x.
-
-        Optional args lo (default 0) and hi (default len(a)) bound the
-        slice of a to be searched.
-        """
-        ...
+"""
+Bisection algorithms.
+
+This module provides support for maintaining a list in sorted order without
+having to sort the list after each insertion. For long lists of items with
+expensive comparison operations, this can be an improvement over the more
+common approach.
+"""
+
+import sys
+from _typeshed import SupportsLenAndGetItem, SupportsRichComparisonT
+from collections.abc import Callable, MutableSequence
+from typing import TypeVar, overload
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 10):
+    @overload
+    def bisect_left(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> int:
+        """
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e < x, and all e in
+        a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
+        insert just before the leftmost x already there.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def bisect_left(
+        a: SupportsLenAndGetItem[_T],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> int:
+        """
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e < x, and all e in
+        a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
+        insert just before the leftmost x already there.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def bisect_right(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> int:
+        """
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e <= x, and all e in
+        a[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will
+        insert just after the rightmost x already there.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def bisect_right(
+        a: SupportsLenAndGetItem[_T],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> int:
+        """
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e <= x, and all e in
+        a[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will
+        insert just after the rightmost x already there.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def insort_left(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> None:
+        """
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the left of the leftmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def insort_left(
+        a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
+    ) -> None:
+        """
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the left of the leftmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def insort_right(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> None:
+        """
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the right of the rightmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    @overload
+    def insort_right(
+        a: MutableSequence[_T], x: _T, lo: int = 0, hi: int | None = None, *, key: Callable[[_T], SupportsRichComparisonT]
+    ) -> None:
+        """
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the right of the rightmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+
+else:
+    def bisect_left(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
+    ) -> int:
+        """
+        bisect_left(a, x[, lo[, hi]]) -> index
+
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e < x, and all e in
+        a[i:] have e >= x.  So if x already appears in the list, i points just
+        before the leftmost x already there.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    def bisect_right(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
+    ) -> int:
+        """
+        bisect_right(a, x[, lo[, hi]]) -> index
+
+        Return the index where to insert item x in list a, assuming a is sorted.
+
+        The return value i is such that all e in a[:i] have e <= x, and all e in
+        a[i:] have e > x.  So if x already appears in the list, i points just
+        beyond the rightmost x already there
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    def insort_left(
+        a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
+    ) -> None:
+        """
+        insort_left(a, x[, lo[, hi]])
+
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the left of the leftmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...
+    def insort_right(
+        a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | None = None
+    ) -> None:
+        """
+        insort_right(a, x[, lo[, hi]])
+
+        Insert item x in list a, and keep it sorted assuming a is sorted.
+
+        If x is already in a, insert it to the right of the rightmost x.
+
+        Optional args lo (default 0) and hi (default len(a)) bound the
+        slice of a to be searched.
+        """
+        ...