basedpyright 1.13.2 → 1.13.3

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.
+        """
+        ...

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

@@ -1 +1 @@
-def getpreferredencoding(do_setlocale: bool = True) -> str: ...
+def getpreferredencoding(do_setlocale: bool = True) -> str: ...

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

@@ -69,23 +69,33 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
-    def __eq__(self, value: object, /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to"""
+            ...
 
 @final
 class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to"""
+            ...
 
 @final
 class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
-    def __eq__(self, value: object, /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
     if sys.version_info >= (3, 10):
         @property
-        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
+            """dictionary that this view refers to"""
+            ...
 
 if sys.version_info >= (3, 12):
     @runtime_checkable