basedpyright 1.1.389 → 1.1.392

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

@@ -1,67 +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:
-    """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)
-    """
-    ...
+"""
+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:
+    """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,83 +1,81 @@
-"""(Extremely) low-level import machinery bits as used by importlib."""
-
-import sys
-import types
-from _typeshed import ReadableBuffer
-from importlib.machinery import ModuleSpec
-from typing import Any
-
-check_hash_based_pycs: str
-
-def source_hash(key: int, source: ReadableBuffer) -> bytes: ...
-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:
-        """
-        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:
-        """Create a code object for a frozen module."""
-        ...
+"""(Extremely) low-level import machinery bits as used by importlib."""
+
+import sys
+import types
+from _typeshed import ReadableBuffer
+from importlib.machinery import ModuleSpec
+from typing import Any
+
+check_hash_based_pycs: str
+
+def source_hash(key: int, source: ReadableBuffer) -> bytes: ...
+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:
+        """
+        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: ...