basedpyright 1.24.0 → 1.25.0

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

@@ -68,15 +68,7 @@ class Future(Awaitable[_T]):
             """
             ...
     else:
-        def cancel(self) -> bool:
-            """
-            Cancel the future and schedule callbacks.
-
-            If the future is already done or cancelled, return False.  Otherwise,
-            change the future's state to cancelled, schedule the callbacks and
-            return True.
-            """
-            ...
+        def cancel(self) -> bool: ...
 
     def cancelled(self) -> bool:
         """Return True if the future was cancelled."""
@@ -246,23 +238,9 @@ class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportIn
             ...
     if sys.version_info < (3, 9):
         @classmethod
-        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None:
-            """
-            Return the currently running task in an event loop or None.
-
-            By default the current task for the current event loop is returned.
-
-            None is returned when called not in the context of a Task.
-            """
-            ...
+        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
         @classmethod
-        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]:
-            """
-            Return a set of all tasks for an event loop.
-
-            By default all tasks for the current event loop are returned.
-            """
-            ...
+        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any, /) -> GenericAlias:
             """See PEP 585"""

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

@@ -177,53 +177,13 @@ if sys.version_info >= (3, 10):
 else:
     def bisect_left(
         a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | 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, 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.
-        """
-        ...
+    ) -> int: ...
     def bisect_right(
         a: SupportsLenAndGetItem[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | 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, 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.
-        """
-        ...
+    ) -> int: ...
     def insort_left(
         a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | 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.
-        """
-        ...
+    ) -> None: ...
     def insort_right(
         a: MutableSequence[SupportsRichComparisonT], x: SupportsRichComparisonT, lo: int = 0, hi: int | 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.
-        """
-        ...
+    ) -> None: ...

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/_csv.pyi

@@ -99,22 +99,8 @@ if sys.version_info >= (3, 10):
                 """
                 ...
         else:
-            def writerow(self, row: Iterable[Any]) -> Any:
-                """
-                writerow(iterable)
-
-                Construct and write a CSV record from an iterable of fields.  Non-string
-                elements will be converted to string.
-                """
-                ...
-            def writerows(self, rows: Iterable[Iterable[Any]]) -> None:
-                """
-                writerows(iterable of iterables)
-
-                Construct and write a series of iterables to a csv file.  Non-string
-                elements will be converted to string.
-                """
-                ...
+            def writerow(self, row: Iterable[Any]) -> Any: ...
+            def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
 
     # For the return types below.
     # These aliases can be removed when typeshed drops support for 3.9.

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

@@ -53,16 +53,4 @@ if sys.platform != "win32":
             """
             ...
     else:
-        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm:
-            """
-            Return a database object.
-
-            filename
-              The filename to open.
-            flags
-              How to open the file.  "r" for reading, "w" for writing, etc.
-            mode
-              If creating a new file, the mode bits for the new file
-              (e.g. os.O_RDWR).
-            """
-            ...
+        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...

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

@@ -73,14 +73,7 @@ if sys.version_info >= (3, 11):
         ...
 
 else:
-    def localcontext(ctx: Context | None = None) -> _ContextManager:
-        """
-        Return a context manager that will set the default context to a copy of ctx
-        on entry to the with-statement and restore the previous default context when
-        exiting the with-statement. If no context is specified, a copy of the current
-        default context is used.
-        """
-        ...
+    def localcontext(ctx: Context | None = None) -> _ContextManager: ...
 
 DefaultContext: Context
 BasicContext: Context

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

@@ -1,33 +1,33 @@
-from collections.abc import Callable
-from types import TracebackType
-from typing import Any, NoReturn, overload
-from typing_extensions import TypeVarTuple, Unpack
-
-__all__ = ["error", "start_new_thread", "exit", "get_ident", "allocate_lock", "interrupt_main", "LockType", "RLock"]
-
-_Ts = TypeVarTuple("_Ts")
-
-TIMEOUT_MAX: int
-error = RuntimeError
-
-@overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> None: ...
-@overload
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> None: ...
-def exit() -> NoReturn: ...
-def get_ident() -> int: ...
-def allocate_lock() -> LockType: ...
-def stack_size(size: int | None = None) -> int: ...
-
-class LockType:
-    locked_status: bool
-    def acquire(self, waitflag: bool | None = None, timeout: int = -1) -> bool: ...
-    def __enter__(self, waitflag: bool | None = None, timeout: int = -1) -> bool: ...
-    def __exit__(self, typ: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None) -> None: ...
-    def release(self) -> bool: ...
-    def locked(self) -> bool: ...
-
-class RLock(LockType):
-    def release(self) -> None: ...  # type: ignore[override]
-
-def interrupt_main() -> None: ...
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, NoReturn, overload
+from typing_extensions import TypeVarTuple, Unpack
+
+__all__ = ["error", "start_new_thread", "exit", "get_ident", "allocate_lock", "interrupt_main", "LockType", "RLock"]
+
+_Ts = TypeVarTuple("_Ts")
+
+TIMEOUT_MAX: int
+error = RuntimeError
+
+@overload
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> None: ...
+@overload
+def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> None: ...
+def exit() -> NoReturn: ...
+def get_ident() -> int: ...
+def allocate_lock() -> LockType: ...
+def stack_size(size: int | None = None) -> int: ...
+
+class LockType:
+    locked_status: bool
+    def acquire(self, waitflag: bool | None = None, timeout: int = -1) -> bool: ...
+    def __enter__(self, waitflag: bool | None = None, timeout: int = -1) -> bool: ...
+    def __exit__(self, typ: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None) -> None: ...
+    def release(self) -> bool: ...
+    def locked(self) -> bool: ...
+
+class RLock(LockType):
+    def release(self) -> None: ...  # type: ignore[override]
+
+def interrupt_main() -> None: ...

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

@@ -1,180 +1,164 @@
-import sys
-from _thread import _excepthook, _ExceptHookArgs
-from _typeshed import ProfileFunction, TraceFunction
-from collections.abc import Callable, Iterable, Mapping
-from types import TracebackType
-from typing import Any, TypeVar
-
-_T = TypeVar("_T")
-
-__all__ = [
-    "get_ident",
-    "active_count",
-    "Condition",
-    "current_thread",
-    "enumerate",
-    "main_thread",
-    "TIMEOUT_MAX",
-    "Event",
-    "Lock",
-    "RLock",
-    "Semaphore",
-    "BoundedSemaphore",
-    "Thread",
-    "Barrier",
-    "BrokenBarrierError",
-    "Timer",
-    "ThreadError",
-    "setprofile",
-    "settrace",
-    "local",
-    "stack_size",
-    "ExceptHookArgs",
-    "excepthook",
-]
-
-def active_count() -> int: ...
-def current_thread() -> Thread: ...
-def currentThread() -> Thread: ...
-def get_ident() -> int: ...
-def enumerate() -> list[Thread]: ...
-def main_thread() -> Thread: ...
-def settrace(func: TraceFunction) -> None: ...
-def setprofile(func: ProfileFunction | None) -> None: ...
-def stack_size(size: int | None = None) -> int: ...
-
-TIMEOUT_MAX: float
-
-class ThreadError(Exception):
-    """Unspecified run-time error."""
-    ...
-
-class local:
-    def __getattribute__(self, name: str) -> Any: ...
-    def __setattr__(self, name: str, value: Any) -> None: ...
-    def __delattr__(self, name: str) -> None: ...
-
-class Thread:
-    name: str
-    daemon: bool
-    @property
-    def ident(self) -> int | None:
-        """
-        Thread identifier of this thread or None if it has not been started.
-
-        This is a nonzero integer. See the get_ident() function. Thread
-        identifiers may be recycled when a thread exits and another thread is
-        created. The identifier is available even after the thread has exited.
-        """
-        ...
-    def __init__(
-        self,
-        group: None = None,
-        target: Callable[..., object] | None = None,
-        name: str | None = None,
-        args: Iterable[Any] = (),
-        kwargs: Mapping[str, Any] | None = None,
-        *,
-        daemon: bool | None = None,
-    ) -> None: ...
-    def start(self) -> None: ...
-    def run(self) -> None: ...
-    def join(self, timeout: float | None = None) -> None: ...
-    def getName(self) -> str: ...
-    def setName(self, name: str) -> None: ...
-    @property
-    def native_id(self) -> int | None: ...  # only available on some platforms
-    def is_alive(self) -> bool: ...
-    if sys.version_info < (3, 9):
-        def isAlive(self) -> bool: ...
-
-    def isDaemon(self) -> bool: ...
-    def setDaemon(self, daemonic: bool) -> None: ...
-
-class _DummyThread(Thread): ...
-
-class Lock:
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def locked(self) -> bool: ...
-
-class _RLock:
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
-    def release(self) -> None: ...
-
-RLock = _RLock
-
-class Condition:
-    def __init__(self, lock: Lock | _RLock | None = None) -> None: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-    def wait_for(self, predicate: Callable[[], _T], timeout: float | None = None) -> _T: ...
-    def notify(self, n: int = 1) -> None: ...
-    def notify_all(self) -> None: ...
-    def notifyAll(self) -> None: ...
-
-class Semaphore:
-    def __init__(self, value: int = 1) -> None: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
-    def __enter__(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def release(self, n: int = ...) -> None: ...
-    else:
-        def release(self) -> None: ...
-
-class BoundedSemaphore(Semaphore): ...
-
-class Event:
-    def is_set(self) -> bool: ...
-    def set(self) -> None: ...
-    def clear(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-
-excepthook = _excepthook
-ExceptHookArgs = _ExceptHookArgs
-
-class Timer(Thread):
-    def __init__(
-        self,
-        interval: float,
-        function: Callable[..., object],
-        args: Iterable[Any] | None = None,
-        kwargs: Mapping[str, Any] | None = None,
-    ) -> None: ...
-    def cancel(self) -> None: ...
-
-class Barrier:
-    @property
-    def parties(self) -> int:
-        """Return the number of threads required to trip the barrier."""
-        ...
-    @property
-    def n_waiting(self) -> int:
-        """Return the number of threads currently waiting at the barrier."""
-        ...
-    @property
-    def broken(self) -> bool:
-        """Return True if the barrier is in a broken state."""
-        ...
-    def __init__(self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None) -> None: ...
-    def wait(self, timeout: float | None = None) -> int: ...
-    def reset(self) -> None: ...
-    def abort(self) -> None: ...
-
-class BrokenBarrierError(RuntimeError): ...
+import sys
+from _thread import _excepthook, _ExceptHookArgs
+from _typeshed import ProfileFunction, TraceFunction
+from collections.abc import Callable, Iterable, Mapping
+from types import TracebackType
+from typing import Any, TypeVar
+
+_T = TypeVar("_T")
+
+__all__ = [
+    "get_ident",
+    "active_count",
+    "Condition",
+    "current_thread",
+    "enumerate",
+    "main_thread",
+    "TIMEOUT_MAX",
+    "Event",
+    "Lock",
+    "RLock",
+    "Semaphore",
+    "BoundedSemaphore",
+    "Thread",
+    "Barrier",
+    "BrokenBarrierError",
+    "Timer",
+    "ThreadError",
+    "setprofile",
+    "settrace",
+    "local",
+    "stack_size",
+    "ExceptHookArgs",
+    "excepthook",
+]
+
+def active_count() -> int: ...
+def current_thread() -> Thread: ...
+def currentThread() -> Thread: ...
+def get_ident() -> int: ...
+def enumerate() -> list[Thread]: ...
+def main_thread() -> Thread: ...
+def settrace(func: TraceFunction) -> None: ...
+def setprofile(func: ProfileFunction | None) -> None: ...
+def stack_size(size: int | None = None) -> int: ...
+
+TIMEOUT_MAX: float
+
+class ThreadError(Exception): ...
+
+class local:
+    def __getattribute__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __delattr__(self, name: str) -> None: ...
+
+class Thread:
+    name: str
+    daemon: bool
+    @property
+    def ident(self) -> int | None: ...
+    def __init__(
+        self,
+        group: None = None,
+        target: Callable[..., object] | None = None,
+        name: str | None = None,
+        args: Iterable[Any] = (),
+        kwargs: Mapping[str, Any] | None = None,
+        *,
+        daemon: bool | None = None,
+    ) -> None: ...
+    def start(self) -> None: ...
+    def run(self) -> None: ...
+    def join(self, timeout: float | None = None) -> None: ...
+    def getName(self) -> str: ...
+    def setName(self, name: str) -> None: ...
+    @property
+    def native_id(self) -> int | None: ...  # only available on some platforms
+    def is_alive(self) -> bool: ...
+    if sys.version_info < (3, 9):
+        def isAlive(self) -> bool: ...
+
+    def isDaemon(self) -> bool: ...
+    def setDaemon(self, daemonic: bool) -> None: ...
+
+class _DummyThread(Thread): ...
+
+class Lock:
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> bool | None: ...
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def locked(self) -> bool: ...
+
+class _RLock:
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> bool | None: ...
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+    def release(self) -> None: ...
+
+RLock = _RLock
+
+class Condition:
+    def __init__(self, lock: Lock | _RLock | None = None) -> None: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> bool | None: ...
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+    def wait_for(self, predicate: Callable[[], _T], timeout: float | None = None) -> _T: ...
+    def notify(self, n: int = 1) -> None: ...
+    def notify_all(self) -> None: ...
+    def notifyAll(self) -> None: ...
+
+class Semaphore:
+    def __init__(self, value: int = 1) -> None: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> bool | None: ...
+    def acquire(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
+    def __enter__(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def release(self, n: int = ...) -> None: ...
+    else:
+        def release(self) -> None: ...
+
+class BoundedSemaphore(Semaphore): ...
+
+class Event:
+    def is_set(self) -> bool: ...
+    def set(self) -> None: ...
+    def clear(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+
+excepthook = _excepthook
+ExceptHookArgs = _ExceptHookArgs
+
+class Timer(Thread):
+    def __init__(
+        self,
+        interval: float,
+        function: Callable[..., object],
+        args: Iterable[Any] | None = None,
+        kwargs: Mapping[str, Any] | None = None,
+    ) -> None: ...
+    def cancel(self) -> None: ...
+
+class Barrier:
+    @property
+    def parties(self) -> int: ...
+    @property
+    def n_waiting(self) -> int: ...
+    @property
+    def broken(self) -> bool: ...
+    def __init__(self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None) -> None: ...
+    def wait(self, timeout: float | None = None) -> int: ...
+    def reset(self) -> None: ...
+    def abort(self) -> None: ...
+
+class BrokenBarrierError(RuntimeError): ...

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

@@ -1,16 +1,3 @@
-"""
-This module provides an interface to the GNU DBM (GDBM) library.
-
-This module is quite similar to the dbm module, but uses GDBM instead to
-provide some additional functionality.  Please note that the file formats
-created by GDBM and dbm are incompatible.
-
-GDBM objects behave like mappings (dictionaries), except that keys and
-values are always immutable bytes-like objects or strings.  Printing
-a GDBM object doesn't print the keys and values, and the items() and
-values() methods are not supported.
-"""
-
 import sys
 from _typeshed import ReadOnlyBuffer, StrOrBytesPath
 from types import TracebackType
@@ -55,31 +42,6 @@ if sys.platform != "win32":
         __init__: None  # type: ignore[assignment]
 
     if sys.version_info >= (3, 11):
-        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm:
-            """
-            Open a dbm database and return a dbm object.
-
-            The filename argument is the name of the database file.
-
-            The optional flags argument can be 'r' (to open an existing database
-            for reading only -- default), 'w' (to open an existing database for
-            reading and writing), 'c' (which creates the database if it doesn't
-            exist), or 'n' (which always creates a new empty database).
-
-            Some versions of gdbm support additional flags which must be
-            appended to one of the flags described above.  The module constant
-            'open_flags' is a string of valid additional flags.  The 'f' flag
-            opens the database in fast mode; altered data will not automatically
-            be written to the disk after every change.  This results in faster
-            writes to the database, but may result in an inconsistent database
-            if the program crashes while the database is still open.  Use the
-            sync() method to force any unwritten data to be written to the disk.
-            The 's' flag causes all database operations to be synchronized to
-            disk.  The 'u' flag disables locking of the database file.
-
-            The optional mode argument is the Unix mode of the file, used only
-            when the database has to be created.  It defaults to octal 0o666.
-            """
-            ...
+        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
     else:
         def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...