basedpyright 1.12.6 → 1.13.0

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

@@ -1,11 +1,67 @@
+"""
+Heap queue algorithm (a.k.a. priority queue).
+
+Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
+all k, counting elements from 0.  For the sake of comparison,
+non-existing elements are considered to be infinite.  The interesting
+property of a heap is that a[0] is always its smallest element.
+
+Usage:
+
+heap = []            # creates an empty heap
+heappush(heap, item) # pushes a new item on the heap
+item = heappop(heap) # pops the smallest item from the heap
+item = heap[0]       # smallest item on the heap without popping it
+heapify(x)           # transforms list into a heap, in-place, in linear time
+item = heapreplace(heap, item) # pops and returns smallest item, and adds
+                               # new item; the heap size is unchanged
+
+Our API differs from textbook heap algorithms as follows:
+
+- We use 0-based indexing.  This makes the relationship between the
+  index for a node and the indexes for its children slightly less
+  obvious, but is more suitable since Python uses 0-based indexing.
+
+- Our heappop() method returns the smallest item, not the largest.
+
+These two make it possible to view the heap as a regular Python list
+without surprises: heap[0] is the smallest item, and heap.sort()
+maintains the heap invariant!
+"""
+
 from typing import Any, Final, TypeVar
 
 _T = TypeVar("_T")
 
 __about__: Final[str]
 
-def heapify(heap: list[Any], /) -> None: ...
-def heappop(heap: list[_T], /) -> _T: ...
-def heappush(heap: list[_T], item: _T, /) -> None: ...
-def heappushpop(heap: list[_T], item: _T, /) -> _T: ...
-def heapreplace(heap: list[_T], item: _T, /) -> _T: ...
+def heapify(heap: list[Any], /) -> None:
+    """Transform list into a heap, in-place, in O(len(heap)) time."""
+    ...
+def heappop(heap: list[_T], /) -> _T:
+    """Pop the smallest item off the heap, maintaining the heap invariant."""
+    ...
+def heappush(heap: list[_T], item: _T, /) -> None:
+    """Push item onto heap, maintaining the heap invariant."""
+    ...
+def heappushpop(heap: list[_T], item: _T, /) -> _T:
+    """
+    Push item on the heap, then pop and return the smallest item from the heap.
+
+    The combined action runs more efficiently than heappush() followed by
+    a separate call to heappop().
+    """
+    ...
+def heapreplace(heap: list[_T], item: _T, /) -> _T:
+    """
+    Pop and return the current smallest value, and add the new item.
+
+    This is more efficient than heappop() followed by heappush(), and can be
+    more appropriate when using a fixed-size heap.  Note that the value
+    returned may be larger than item!  That constrains reasonable uses of
+    this routine unless written as part of a conditional replacement:
+
+        if item > heap[0]:
+            item = heapreplace(heap, item)
+    """
+    ...

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

@@ -1,3 +1,5 @@
+"""(Extremely) low-level import machinery bits as used by importlib and imp."""
+
 import sys
 import types
 from _typeshed import ReadableBuffer
@@ -7,22 +9,75 @@ from typing import Any
 check_hash_based_pycs: str
 
 def source_hash(key: int, source: ReadableBuffer) -> bytes: ...
-def create_builtin(spec: ModuleSpec, /) -> types.ModuleType: ...
-def create_dynamic(spec: ModuleSpec, file: Any = None, /) -> types.ModuleType: ...
-def acquire_lock() -> None: ...
-def exec_builtin(mod: types.ModuleType, /) -> int: ...
-def exec_dynamic(mod: types.ModuleType, /) -> int: ...
-def extension_suffixes() -> list[str]: ...
-def init_frozen(name: str, /) -> types.ModuleType: ...
-def is_builtin(name: str, /) -> int: ...
-def is_frozen(name: str, /) -> bool: ...
-def is_frozen_package(name: str, /) -> bool: ...
-def lock_held() -> bool: ...
-def release_lock() -> None: ...
+def create_builtin(spec: ModuleSpec, /) -> types.ModuleType:
+    """Create an extension module."""
+    ...
+def create_dynamic(spec: ModuleSpec, file: Any = None, /) -> types.ModuleType:
+    """Create an extension module."""
+    ...
+def acquire_lock() -> None:
+    """
+    Acquires the interpreter's import lock for the current thread.
+
+    This lock should be used by import hooks to ensure thread-safety when importing
+    modules. On platforms without threads, this function does nothing.
+    """
+    ...
+def exec_builtin(mod: types.ModuleType, /) -> int:
+    """Initialize a built-in module."""
+    ...
+def exec_dynamic(mod: types.ModuleType, /) -> int:
+    """Initialize an extension module."""
+    ...
+def extension_suffixes() -> list[str]:
+    """Returns the list of file suffixes used to identify extension modules."""
+    ...
+def init_frozen(name: str, /) -> types.ModuleType:
+    """Initializes a frozen module."""
+    ...
+def is_builtin(name: str, /) -> int:
+    """Returns True if the module name corresponds to a built-in module."""
+    ...
+def is_frozen(name: str, /) -> bool:
+    """Returns True if the module name corresponds to a frozen module."""
+    ...
+def is_frozen_package(name: str, /) -> bool:
+    """Returns True if the module name is of a frozen package."""
+    ...
+def lock_held() -> bool:
+    """
+    Return True if the import lock is currently held, else False.
+
+    On platforms without threads, return False.
+    """
+    ...
+def release_lock() -> None:
+    """
+    Release the interpreter's import lock.
+
+    On platforms without threads, this function does nothing.
+    """
+    ...
 
 if sys.version_info >= (3, 11):
-    def find_frozen(name: str, /, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None: ...
-    def get_frozen_object(name: str, data: ReadableBuffer | None = None, /) -> types.CodeType: ...
+    def find_frozen(name: str, /, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None:
+        """
+        Return info about the corresponding frozen module (if there is one) or None.
+
+        The returned info (a 2-tuple):
+
+         * data         the raw marshalled bytes
+         * is_package   whether or not it is a package
+         * origname     the originally frozen module's name, or None if not
+                        a stdlib module (this will usually be the same as
+                        the module's current name)
+        """
+        ...
+    def get_frozen_object(name: str, data: ReadableBuffer | None = None, /) -> types.CodeType:
+        """Create a code object for a frozen module."""
+        ...
 
 else:
-    def get_frozen_object(name: str, /) -> types.CodeType: ...
+    def get_frozen_object(name: str, /) -> types.CodeType:
+        """Create a code object for a frozen module."""
+        ...

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

@@ -1,24 +1,43 @@
+"""json speedups"""
+
 from collections.abc import Callable
 from typing import Any, final
 
 @final
 class make_encoder:
+    """_iterencode(obj, _current_indent_level) -> iterable"""
     @property
-    def sort_keys(self) -> bool: ...
+    def sort_keys(self) -> bool:
+        """sort_keys"""
+        ...
     @property
-    def skipkeys(self) -> bool: ...
+    def skipkeys(self) -> bool:
+        """skipkeys"""
+        ...
     @property
-    def key_separator(self) -> str: ...
+    def key_separator(self) -> str:
+        """key_separator"""
+        ...
     @property
-    def indent(self) -> int | None: ...
+    def indent(self) -> int | None:
+        """indent"""
+        ...
     @property
-    def markers(self) -> dict[int, Any] | None: ...
+    def markers(self) -> dict[int, Any] | None:
+        """markers"""
+        ...
     @property
-    def default(self) -> Callable[[Any], Any]: ...
+    def default(self) -> Callable[[Any], Any]:
+        """default"""
+        ...
     @property
-    def encoder(self) -> Callable[[str], str]: ...
+    def encoder(self) -> Callable[[str], str]:
+        """encoder"""
+        ...
     @property
-    def item_separator(self) -> str: ...
+    def item_separator(self) -> str:
+        """item_separator"""
+        ...
     def __init__(
         self,
         markers: dict[int, Any] | None,
@@ -31,10 +50,13 @@ class make_encoder:
         skipkeys: bool,
         allow_nan: bool,
     ) -> None: ...
-    def __call__(self, obj: object, _current_indent_level: int) -> Any: ...
+    def __call__(self, obj: object, _current_indent_level: int) -> Any:
+        """Call self as a function."""
+        ...
 
 @final
 class make_scanner:
+    """JSON scanner object"""
     object_hook: Any
     object_pairs_hook: Any
     parse_int: Any
@@ -43,7 +65,28 @@ class make_scanner:
     strict: bool
     # TODO: 'context' needs the attrs above (ducktype), but not __call__.
     def __init__(self, context: make_scanner) -> None: ...
-    def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
+    def __call__(self, string: str, index: int) -> tuple[Any, int]:
+        """Call self as a function."""
+        ...
+
+def encode_basestring_ascii(s: str, /) -> str:
+    """
+    encode_basestring_ascii(string) -> string
+
+    Return an ASCII-only JSON representation of a Python string
+    """
+    ...
+def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]:
+    """
+    scanstring(string, end, strict=True) -> (string, end)
+
+    Scan the string s for a JSON string. End is the index of the
+    character in s after the quote that started the JSON string.
+    Unescapes all valid JSON string escape sequences and raises ValueError
+    on attempt to decode an invalid string. If strict is False then literal
+    control characters are allowed in the string.
 
-def encode_basestring_ascii(s: str, /) -> str: ...
-def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...
+    Returns a tuple of the decoded string and the index of the character in s
+    after the end quote.
+    """
+    ...

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

@@ -1,3 +1,5 @@
+"""Support for POSIX locales."""
+
 import sys
 from _typeshed import StrPath
 from collections.abc import Mapping
@@ -10,14 +12,28 @@ LC_NUMERIC: int
 LC_ALL: int
 CHAR_MAX: int
 
-def setlocale(category: int, locale: str | None = None, /) -> str: ...
-def localeconv() -> Mapping[str, int | str | list[int]]: ...
+def setlocale(category: int, locale: str | None = None, /) -> str:
+    """(integer,string=None) -> string. Activates/queries locale processing."""
+    ...
+def localeconv() -> Mapping[str, int | str | list[int]]:
+    """() -> dict. Returns numeric and monetary locale-specific parameters."""
+    ...
 
 if sys.version_info >= (3, 11):
-    def getencoding() -> str: ...
+    def getencoding() -> str:
+        """Get the current locale encoding."""
+        ...
+
+def strcoll(os1: str, os2: str, /) -> int:
+    """string,string -> int. Compares two strings according to the locale."""
+    ...
+def strxfrm(string: str, /) -> str:
+    """
+    strxfrm(string) -> string.
 
-def strcoll(os1: str, os2: str, /) -> int: ...
-def strxfrm(string: str, /) -> str: ...
+    Return a string that can be used as a key for locale-aware comparisons.
+    """
+    ...
 
 # native gettext functions
 # https://docs.python.org/3/library/locale.html#access-to-message-catalogs
@@ -87,14 +103,49 @@ if sys.platform != "win32":
     CRNCYSTR: int
     ALT_DIGITS: int
 
-    def nl_langinfo(key: int, /) -> str: ...
+    def nl_langinfo(key: int, /) -> str:
+        """
+        nl_langinfo(key) -> string
+        Return the value for the locale information associated with key.
+        """
+        ...
 
     # This is dependent on `libintl.h` which is a part of `gettext`
     # system dependency. These functions might be missing.
     # But, we always say that they are present.
-    def gettext(msg: str, /) -> str: ...
-    def dgettext(domain: str | None, msg: str, /) -> str: ...
-    def dcgettext(domain: str | None, msg: str, category: int, /) -> str: ...
-    def textdomain(domain: str | None, /) -> str: ...
-    def bindtextdomain(domain: str, dir: StrPath | None, /) -> str: ...
-    def bind_textdomain_codeset(domain: str, codeset: str | None, /) -> str | None: ...
+    def gettext(msg: str, /) -> str:
+        """
+        gettext(msg) -> string
+        Return translation of msg.
+        """
+        ...
+    def dgettext(domain: str | None, msg: str, /) -> str:
+        """
+        dgettext(domain, msg) -> string
+        Return translation of msg in domain.
+        """
+        ...
+    def dcgettext(domain: str | None, msg: str, category: int, /) -> str:
+        """
+        dcgettext(domain, msg, category) -> string
+        Return translation of msg in domain and category.
+        """
+        ...
+    def textdomain(domain: str | None, /) -> str:
+        """
+        textdomain(domain) -> string
+        Set the C library's textdmain to domain, returning the new domain.
+        """
+        ...
+    def bindtextdomain(domain: str, dir: StrPath | None, /) -> str:
+        """
+        bindtextdomain(domain, dir) -> string
+        Bind the C library's domain to dir.
+        """
+        ...
+    def bind_textdomain_codeset(domain: str, codeset: str | None, /) -> str | None:
+        """
+        bind_textdomain_codeset(domain, codeset) -> string
+        Bind the C library's domain to codeset.
+        """
+        ...

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

@@ -1,3 +1,5 @@
+"""Fast profiler"""
+
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
@@ -5,13 +7,68 @@ from types import CodeType
 from typing import Any, Final, final
 
 class Profiler:
+    """
+    Profiler(timer=None, timeunit=None, subcalls=True, builtins=True)
+
+    Builds a profiler object using the specified timer function.
+    The default timer is a fast built-in one based on real time.
+    For custom timer functions returning integers, timeunit can
+    be a float specifying a scale (i.e. how long each integer unit
+    is, in seconds).
+    """
     def __init__(
         self, timer: Callable[[], float] | None = None, timeunit: float = 0.0, subcalls: bool = True, builtins: bool = True
     ) -> None: ...
-    def getstats(self) -> list[profiler_entry]: ...
-    def enable(self, subcalls: bool = True, builtins: bool = True) -> None: ...
-    def disable(self) -> None: ...
-    def clear(self) -> None: ...
+    def getstats(self) -> list[profiler_entry]:
+        """
+        getstats() -> list of profiler_entry objects
+
+        Return all information collected by the profiler.
+        Each profiler_entry is a tuple-like object with the
+        following attributes:
+
+            code          code object
+            callcount     how many times this was called
+            reccallcount  how many times called recursively
+            totaltime     total time in this entry
+            inlinetime    inline time in this entry (not in subcalls)
+            calls         details of the calls
+
+        The calls attribute is either None or a list of
+        profiler_subentry objects:
+
+            code          called code object
+            callcount     how many times this is called
+            reccallcount  how many times this is called recursively
+            totaltime     total time spent in this call
+            inlinetime    inline time (not in further subcalls)
+        """
+        ...
+    def enable(self, subcalls: bool = True, builtins: bool = True) -> None:
+        """
+        enable(subcalls=True, builtins=True)
+
+        Start collecting profiling information.
+        If 'subcalls' is True, also records for each function
+        statistics separated according to its current caller.
+        If 'builtins' is True, records the time spent in
+        built-in functions separately from their caller.
+        """
+        ...
+    def disable(self) -> None:
+        """
+        disable()
+
+        Stop collecting profiling information.
+        """
+        ...
+    def clear(self) -> None:
+        """
+        clear()
+
+        Clear all profiling information collected so far.
+        """
+        ...
 
 @final
 class profiler_entry(structseq[Any], tuple[CodeType | str, int, int, float, float, list[profiler_subentry]]):