basedpyright 1.13.2 → 1.13.3

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

@@ -32,21 +32,48 @@ class PurePath(PathLike[str]):
         def full_match(self, pattern: StrPath, *, case_sensitive: bool | None = None) -> bool: ...
 
     @property
-    def parts(self) -> tuple[str, ...]: ...
+    def parts(self) -> tuple[str, ...]:
+        """
+        An object providing sequence-like access to the
+        components in the filesystem path.
+        """
+        ...
     @property
-    def drive(self) -> str: ...
+    def drive(self) -> str:
+        """The drive prefix (letter or UNC path), if any."""
+        ...
     @property
-    def root(self) -> str: ...
+    def root(self) -> str:
+        """The root of the path, if any."""
+        ...
     @property
-    def anchor(self) -> str: ...
+    def anchor(self) -> str:
+        """The concatenation of the drive and root, or ''."""
+        ...
     @property
-    def name(self) -> str: ...
+    def name(self) -> str:
+        """The final path component, if any."""
+        ...
     @property
-    def suffix(self) -> str: ...
+    def suffix(self) -> str:
+        """
+        The final component's last suffix, if any.
+
+        This includes the leading period. For example: '.txt'
+        """
+        ...
     @property
-    def suffixes(self) -> list[str]: ...
+    def suffixes(self) -> list[str]:
+        """
+        A list of the final component's suffixes, if any.
+
+        These include the leading periods. For example: ['.tar', '.gz']
+        """
+        ...
     @property
-    def stem(self) -> str: ...
+    def stem(self) -> str:
+        """The final path component, minus its last suffix."""
+        ...
     if sys.version_info >= (3, 12):
         def __new__(cls, *args: StrPath, **kwargs: Unused) -> Self: ...
         def __init__(self, *args: StrPath) -> None: ...
@@ -88,9 +115,13 @@ class PurePath(PathLike[str]):
     def with_suffix(self, suffix: str) -> Self: ...
     def joinpath(self, *other: StrPath) -> Self: ...
     @property
-    def parents(self) -> Sequence[Self]: ...
+    def parents(self) -> Sequence[Self]:
+        """A sequence of this path's logical parents."""
+        ...
     @property
-    def parent(self) -> Self: ...
+    def parent(self) -> Self:
+        """The logical parent of the path."""
+        ...
     if sys.version_info >= (3, 9) and sys.version_info < (3, 11):
         def __class_getitem__(cls, type: Any) -> GenericAlias: ...
 
@@ -113,7 +144,7 @@ class Path(PurePath):
 
     if sys.version_info >= (3, 13):
         @classmethod
-        def from_uri(cls, uri: str) -> Path: ...
+        def from_uri(cls, uri: str) -> Self: ...
         def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
         def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
         def read_text(self, encoding: str | None = None, errors: str | None = None, newline: str | None = None) -> str: ...

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

@@ -100,10 +100,21 @@ class _ReadableFileobj(Protocol):
 @final
 class PickleBuffer:
     def __init__(self, buffer: ReadableBuffer) -> None: ...
-    def raw(self) -> memoryview: ...
-    def release(self) -> None: ...
-    def __buffer__(self, flags: int, /) -> memoryview: ...
-    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    def raw(self) -> memoryview:
+        """
+        Return a memoryview of the raw memory underlying this buffer.
+        Will raise BufferError is the buffer isn't contiguous.
+        """
+        ...
+    def release(self) -> None:
+        """Release the underlying buffer exposed by the PickleBuffer object."""
+        ...
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object."""
+        ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None:
+        """Release the buffer object that exposes the underlying memory of the object."""
+        ...
 
 _BufferCallback: TypeAlias = Callable[[PickleBuffer], Any] | None
 
@@ -114,10 +125,60 @@ def dump(
     *,
     fix_imports: bool = True,
     buffer_callback: _BufferCallback = None,
-) -> None: ...
+) -> None:
+    """
+    Write a pickled representation of obj to the open file object file.
+
+    This is equivalent to ``Pickler(file, protocol).dump(obj)``, but may
+    be more efficient.
+
+    The optional *protocol* argument tells the pickler to use the given
+    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+    protocol is 4. It was introduced in Python 3.4, and is incompatible
+    with previous versions.
+
+    Specifying a negative protocol version selects the highest protocol
+    version supported.  The higher the protocol used, the more recent the
+    version of Python needed to read the pickle produced.
+
+    The *file* argument must have a write() method that accepts a single
+    bytes argument.  It can thus be a file object opened for binary
+    writing, an io.BytesIO instance, or any other custom object that meets
+    this interface.
+
+    If *fix_imports* is True and protocol is less than 3, pickle will try
+    to map the new Python 3 names to the old module names used in Python
+    2, so that the pickle data stream is readable with Python 2.
+
+    If *buffer_callback* is None (the default), buffer views are serialized
+    into *file* as part of the pickle stream.  It is an error if
+    *buffer_callback* is not None and *protocol* is None or smaller than 5.
+    """
+    ...
 def dumps(
     obj: Any, protocol: int | None = None, *, fix_imports: bool = True, buffer_callback: _BufferCallback = None
-) -> bytes: ...
+) -> bytes:
+    """
+    Return the pickled representation of the object as a bytes object.
+
+    The optional *protocol* argument tells the pickler to use the given
+    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+    protocol is 4. It was introduced in Python 3.4, and is incompatible
+    with previous versions.
+
+    Specifying a negative protocol version selects the highest protocol
+    version supported.  The higher the protocol used, the more recent the
+    version of Python needed to read the pickle produced.
+
+    If *fix_imports* is True and *protocol* is less than 3, pickle will
+    try to map the new Python 3 names to the old module names used in
+    Python 2, so that the pickle data stream is readable with Python 2.
+
+    If *buffer_callback* is None (the default), buffer views are serialized
+    into *file* as part of the pickle stream.  It is an error if
+    *buffer_callback* is not None and *protocol* is None or smaller than 5.
+    """
+    ...
 def load(
     file: _ReadableFileobj,
     *,
@@ -125,7 +186,33 @@ def load(
     encoding: str = "ASCII",
     errors: str = "strict",
     buffers: Iterable[Any] | None = (),
-) -> Any: ...
+) -> Any:
+    """
+    Read and return an object from the pickle data stored in a file.
+
+    This is equivalent to ``Unpickler(file).load()``, but may be more
+    efficient.
+
+    The protocol version of the pickle is detected automatically, so no
+    protocol argument is needed.  Bytes past the pickled object's
+    representation are ignored.
+
+    The argument *file* must have two methods, a read() method that takes
+    an integer argument, and a readline() method that requires no
+    arguments.  Both methods should return bytes.  Thus *file* can be a
+    binary file object opened for reading, an io.BytesIO object, or any
+    other custom object that meets this interface.
+
+    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+    which are used to control compatibility support for pickle stream
+    generated by Python 2.  If *fix_imports* is True, pickle will try to
+    map the old Python 2 names to the new names used in Python 3.  The
+    *encoding* and *errors* tell pickle how to decode 8-bit string
+    instances pickled by Python 2; these default to 'ASCII' and 'strict',
+    respectively.  The *encoding* can be 'bytes' to read these 8-bit
+    string instances as bytes objects.
+    """
+    ...
 def loads(
     data: ReadableBuffer,
     /,
@@ -134,7 +221,24 @@ def loads(
     encoding: str = "ASCII",
     errors: str = "strict",
     buffers: Iterable[Any] | None = (),
-) -> Any: ...
+) -> Any:
+    """
+    Read and return an object from the given pickle data.
+
+    The protocol version of the pickle is detected automatically, so no
+    protocol argument is needed.  Bytes past the pickled object's
+    representation are ignored.
+
+    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+    which are used to control compatibility support for pickle stream
+    generated by Python 2.  If *fix_imports* is True, pickle will try to
+    map the old Python 2 names to the new names used in Python 3.  The
+    *encoding* and *errors* tell pickle how to decode 8-bit string
+    instances pickled by Python 2; these default to 'ASCII' and 'strict',
+    respectively.  The *encoding* can be 'bytes' to read these 8-bit
+    string instances as bytes objects.
+    """
+    ...
 
 class PickleError(Exception): ...
 class PicklingError(PickleError): ...
@@ -149,6 +253,38 @@ _ReducedType: TypeAlias = (
 )
 
 class Pickler:
+    """
+    This takes a binary file for writing a pickle data stream.
+
+    The optional *protocol* argument tells the pickler to use the given
+    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
+    protocol is 4. It was introduced in Python 3.4, and is incompatible
+    with previous versions.
+
+    Specifying a negative protocol version selects the highest protocol
+    version supported.  The higher the protocol used, the more recent the
+    version of Python needed to read the pickle produced.
+
+    The *file* argument must have a write() method that accepts a single
+    bytes argument. It can thus be a file object opened for binary
+    writing, an io.BytesIO instance, or any other custom object that meets
+    this interface.
+
+    If *fix_imports* is True and protocol is less than 3, pickle will try
+    to map the new Python 3 names to the old module names used in Python
+    2, so that the pickle data stream is readable with Python 2.
+
+    If *buffer_callback* is None (the default), buffer views are
+    serialized into *file* as part of the pickle stream.
+
+    If *buffer_callback* is not None, then it can be called any number
+    of times with a buffer view.  If the callback returns a false value
+    (such as None), the given buffer is out-of-band; otherwise the
+    buffer is serialized in-band, i.e. inside the pickle stream.
+
+    It is an error if *buffer_callback* is not None and *protocol*
+    is None or smaller than 5.
+    """
     fast: bool
     dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
     bin: bool  # undocumented
@@ -163,11 +299,44 @@ class Pickler:
         buffer_callback: _BufferCallback = ...,
     ) -> None: ...
     def reducer_override(self, obj: Any) -> Any: ...
-    def dump(self, obj: Any, /) -> None: ...
-    def clear_memo(self) -> None: ...
+    def dump(self, obj: Any, /) -> None:
+        """Write a pickled representation of the given object to the open file."""
+        ...
+    def clear_memo(self) -> None:
+        """
+        Clears the pickler's "memo".
+
+        The memo is the data structure that remembers which objects the
+        pickler has already seen, so that shared or recursive objects are
+        pickled by reference and not by value.  This method is useful when
+        re-using picklers.
+        """
+        ...
     def persistent_id(self, obj: Any) -> Any: ...
 
 class Unpickler:
+    """
+    This takes a binary file for reading a pickle data stream.
+
+    The protocol version of the pickle is detected automatically, so no
+    protocol argument is needed.  Bytes past the pickled object's
+    representation are ignored.
+
+    The argument *file* must have two methods, a read() method that takes
+    an integer argument, and a readline() method that requires no
+    arguments.  Both methods should return bytes.  Thus *file* can be a
+    binary file object opened for reading, an io.BytesIO object, or any
+    other custom object that meets this interface.
+
+    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
+    which are used to control compatibility support for pickle stream
+    generated by Python 2.  If *fix_imports* is True, pickle will try to
+    map the old Python 2 names to the new names used in Python 3.  The
+    *encoding* and *errors* tell pickle how to decode 8-bit string
+    instances pickled by Python 2; these default to 'ASCII' and 'strict',
+    respectively.  The *encoding* can be 'bytes' to read these 8-bit
+    string instances as bytes objects.
+    """
     dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
 
     def __init__(
@@ -179,8 +348,27 @@ class Unpickler:
         errors: str = ...,
         buffers: Iterable[Any] | None = ...,
     ) -> None: ...
-    def load(self) -> Any: ...
-    def find_class(self, module_name: str, global_name: str, /) -> Any: ...
+    def load(self) -> Any:
+        """
+        Load a pickle.
+
+        Read a pickled object representation from the open file object given
+        in the constructor, and return the reconstituted object hierarchy
+        specified therein.
+        """
+        ...
+    def find_class(self, module_name: str, global_name: str, /) -> Any:
+        """
+        Return an object from a specified module.
+
+        If necessary, the module will be imported. Subclasses may override
+        this method (e.g. to restrict unpickling of arbitrary classes and
+        functions).
+
+        This method is called whenever a class or a function object is
+        needed.  Both arguments passed are str objects.
+        """
+        ...
     def persistent_load(self, pid: Any) -> Any: ...
 
 MARK: bytes

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

@@ -93,9 +93,13 @@ def normcase(s: PathLike[AnyStr]) -> AnyStr: ...
 @overload
 def normcase(s: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
 @overload
-def normpath(path: PathLike[AnyStr]) -> AnyStr: ...
+def normpath(path: PathLike[AnyStr]) -> AnyStr:
+    """Normalize path, eliminating double slashes, etc."""
+    ...
 @overload
-def normpath(path: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
+def normpath(path: AnyOrLiteralStr) -> AnyOrLiteralStr:
+    """Normalize path, eliminating double slashes, etc."""
+    ...
 @overload
 def commonpath(paths: Iterable[LiteralString]) -> LiteralString: ...
 @overload

package/dist/typeshed-fallback/stdlib/pyexpat/errors.pyi

@@ -1,3 +1,5 @@
+"""Constants used to describe error conditions."""
+
 import sys
 
 codes: dict[str, int]

package/dist/typeshed-fallback/stdlib/pyexpat/model.pyi

@@ -1,3 +1,5 @@
+"""Constants used to interpret content model information."""
+
 XML_CTYPE_ANY: int
 XML_CTYPE_CHOICE: int
 XML_CTYPE_EMPTY: int

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

@@ -11,7 +11,9 @@ if sys.version_info >= (3, 13):
 
 _T = TypeVar("_T")
 
-class Empty(Exception): ...
+class Empty(Exception):
+    """Exception raised by Queue.get(block=0)/get_nowait()."""
+    ...
 class Full(Exception): ...
 
 if sys.version_info >= (3, 13):
@@ -48,7 +50,13 @@ class Queue(Generic[_T]):
     def _qsize(self) -> int: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 class PriorityQueue(Queue[_T]):
     queue: list[_T]
@@ -57,12 +65,52 @@ class LifoQueue(Queue[_T]):
     queue: list[_T]
 
 class SimpleQueue(Generic[_T]):
+    """Simple, unbounded, reentrant FIFO queue."""
     def __init__(self) -> None: ...
-    def empty(self) -> bool: ...
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
-    def get_nowait(self) -> _T: ...
-    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
-    def put_nowait(self, item: _T) -> None: ...
-    def qsize(self) -> int: ...
+    def empty(self) -> bool:
+        """Return True if the queue is empty, False otherwise (not reliable!)."""
+        ...
+    def get(self, block: bool = True, timeout: float | None = None) -> _T:
+        """
+        Remove and return an item from the queue.
+
+        If optional args 'block' is true and 'timeout' is None (the default),
+        block if necessary until an item is available. If 'timeout' is
+        a non-negative number, it blocks at most 'timeout' seconds and raises
+        the Empty exception if no item was available within that time.
+        Otherwise ('block' is false), return an item if one is immediately
+        available, else raise the Empty exception ('timeout' is ignored
+        in that case).
+        """
+        ...
+    def get_nowait(self) -> _T:
+        """
+        Remove and return an item from the queue without blocking.
+
+        Only get an item if one is immediately available. Otherwise
+        raise the Empty exception.
+        """
+        ...
+    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None:
+        """
+        Put the item on the queue.
+
+        The optional 'block' and 'timeout' arguments are ignored, as this method
+        never blocks.  They are provided for compatibility with the Queue class.
+        """
+        ...
+    def put_nowait(self, item: _T) -> None:
+        """
+        Put an item into the queue without blocking.
+
+        This is exactly equivalent to `put(item)` and is only provided
+        for compatibility with the Queue class.
+        """
+        ...
+    def qsize(self) -> int:
+        """Return the approximate size of the queue (not reliable!)."""
+        ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...