basedpyright 1.18.4 → 1.19.0

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

@@ -76,7 +76,9 @@ class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
         """Return self==value."""
         ...
     if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
+        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool:
+            """Return True if the view and the given iterable have a null intersection."""
+            ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:
@@ -97,7 +99,9 @@ class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
         """Return self==value."""
         ...
     if sys.version_info >= (3, 13):
-        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
+        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool:
+            """Return True if the view and the given iterable have a null intersection."""
+            ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]:

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

@@ -1,66 +1,4 @@
-r"""
-CSV parsing and writing.
-
-This module provides classes that assist in the reading and writing
-of Comma Separated Value (CSV) files, and implements the interface
-described by PEP 305.  Although many CSV files are simple to parse,
-the format is not formally defined by a stable specification and
-is subtle enough that parsing lines of a CSV file with something
-like line.split(",") is bound to fail.  The module supports three
-basic APIs: reading, writing, and registration of dialects.
-
-
-DIALECT REGISTRATION:
-
-Readers and writers support a dialect argument, which is a convenient
-handle on a group of settings.  When the dialect argument is a string,
-it identifies one of the dialects previously registered with the module.
-If it is a class or instance, the attributes of the argument are used as
-the settings for the reader or writer:
-
-    class excel:
-        delimiter = ','
-        quotechar = '"'
-        escapechar = None
-        doublequote = True
-        skipinitialspace = False
-        lineterminator = '\r\n'
-        quoting = QUOTE_MINIMAL
-
-SETTINGS:
-
-    * quotechar - specifies a one-character string to use as the
-        quoting character.  It defaults to '"'.
-    * delimiter - specifies a one-character string to use as the
-        field separator.  It defaults to ','.
-    * skipinitialspace - specifies how to interpret spaces which
-        immediately follow a delimiter.  It defaults to False, which
-        means that spaces immediately following a delimiter is part
-        of the following field.
-    * lineterminator -  specifies the character sequence which should
-        terminate rows.
-    * quoting - controls when quotes should be generated by the writer.
-        It can take on any of the following module constants:
-
-        csv.QUOTE_MINIMAL means only when required, for example, when a
-            field contains either the quotechar or the delimiter
-        csv.QUOTE_ALL means that quotes are always placed around fields.
-        csv.QUOTE_NONNUMERIC means that quotes are always placed around
-            fields which do not parse as integers or floating point
-            numbers.
-        csv.QUOTE_STRINGS means that quotes are always placed around
-            fields which are strings.  Note that the Python value None
-            is not a string.
-        csv.QUOTE_NOTNULL means that quotes are only placed around fields
-            that are not the Python value None.
-        csv.QUOTE_NONE means that quotes are never placed around fields.
-    * escapechar - specifies a one-character string used to escape
-        the delimiter when quoting is set to QUOTE_NONE.
-    * doublequote - controls the handling of quotes inside fields.  When
-        True, two consecutive quotes are interpreted as one during read,
-        and when writing, each quote character embedded in the data is
-        written as two quotes
-"""
+"""CSV parsing and writing."""
 
 import sys
 from _typeshed import SupportsWrite

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

@@ -109,8 +109,26 @@ class _Pointer(_PointerLike, _CData, Generic[_CT]):
         """Set self[key] to value."""
         ...
 
-def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
-def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
+def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]:
+    """
+    Create and return a new ctypes pointer type.
+
+      type
+        A ctypes type.
+
+    Pointer types are cached and reused internally,
+    so calling this function repeatedly is cheap.
+    """
+    ...
+def pointer(obj: _CT, /) -> _Pointer[_CT]:
+    """
+    Create a new pointer instance, pointing to 'obj'.
+
+    The returned object is of the type POINTER(type(obj)). Note that if you
+    just want to pass a pointer to an object to a foreign function call, you
+    should use byref(obj) which is much faster.
+    """
+    ...
 
 class _CArgObject: ...
 
@@ -181,7 +199,15 @@ class Structure(_StructUnionBase):
     ...
 
 class Array(_CData, Generic[_CT]):
-    """XXX to be provided"""
+    """
+    Abstract base class for arrays.
+
+    The recommended way to create concrete array types is by multiplying any
+    ctypes data type with a non-negative integer. Alternatively, you can subclass
+    this type and define _length_ and _type_ class variables. Array elements can
+    be read and written using standard subscript and slice accesses for slice
+    reads, the resulting object is not itself an Array.
+    """
     @property
     @abstractmethod
     def _length_(self) -> int: ...

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

@@ -1,86 +1,258 @@
-from _typeshed import structseq
-from typing import Any, Final, Literal, SupportsIndex, final
-from typing_extensions import Buffer, Self
-
-class ChannelError(RuntimeError): ...
-class ChannelClosedError(ChannelError): ...
-class ChannelEmptyError(ChannelError): ...
-class ChannelNotEmptyError(ChannelError): ...
-class ChannelNotFoundError(ChannelError): ...
-
-# Mark as final, since instantiating ChannelID is not supported.
-@final
-class ChannelID:
-    @property
-    def end(self) -> Literal["send", "recv", "both"]: ...
-    @property
-    def send(self) -> Self: ...
-    @property
-    def recv(self) -> Self: ...
-    def __eq__(self, other: object) -> bool: ...
-    def __ge__(self, other: ChannelID) -> bool: ...
-    def __gt__(self, other: ChannelID) -> bool: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __int__(self) -> int: ...
-    def __le__(self, other: ChannelID) -> bool: ...
-    def __lt__(self, other: ChannelID) -> bool: ...
-    def __ne__(self, other: object) -> bool: ...
-
-@final
-class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
-    __match_args__: Final = (
-        "open",
-        "closing",
-        "closed",
-        "count",
-        "num_interp_send",
-        "num_interp_send_released",
-        "num_interp_recv",
-        "num_interp_recv_released",
-    )
-    @property
-    def open(self) -> bool: ...
-    @property
-    def closing(self) -> bool: ...
-    @property
-    def closed(self) -> bool: ...
-    @property
-    def count(self) -> int: ...  # type: ignore[override]
-    @property
-    def num_interp_send(self) -> int: ...
-    @property
-    def num_interp_send_released(self) -> int: ...
-    @property
-    def num_interp_recv(self) -> int: ...
-    @property
-    def num_interp_recv_released(self) -> int: ...
-    @property
-    def num_interp_both(self) -> int: ...
-    @property
-    def num_interp_both_recv_released(self) -> int: ...
-    @property
-    def num_interp_both_send_released(self) -> int: ...
-    @property
-    def num_interp_both_released(self) -> int: ...
-    @property
-    def recv_associated(self) -> bool: ...
-    @property
-    def recv_released(self) -> bool: ...
-    @property
-    def send_associated(self) -> bool: ...
-    @property
-    def send_released(self) -> bool: ...
-
-def create(unboundop: Literal[1, 2, 3]) -> ChannelID: ...
-def destroy(cid: SupportsIndex) -> None: ...
-def list_all() -> list[ChannelID]: ...
-def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]: ...
-def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None: ...
-def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None: ...
-def recv(cid: SupportsIndex, default: object = ...) -> tuple[Any, Literal[1, 2, 3]]: ...
-def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
-def get_count(cid: SupportsIndex) -> int: ...
-def get_info(cid: SupportsIndex) -> ChannelInfo: ...
-def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]: ...
-def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...
+"""
+This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
+
+from _typeshed import structseq
+from typing import Any, Final, Literal, SupportsIndex, final
+from typing_extensions import Buffer, Self
+
+class ChannelError(RuntimeError): ...
+class ChannelClosedError(ChannelError): ...
+class ChannelEmptyError(ChannelError): ...
+class ChannelNotEmptyError(ChannelError): ...
+class ChannelNotFoundError(ChannelError): ...
+
+# Mark as final, since instantiating ChannelID is not supported.
+@final
+class ChannelID:
+    """A channel ID identifies a channel and may be used as an int."""
+    @property
+    def end(self) -> Literal["send", "recv", "both"]:
+        """'send', 'recv', or 'both'"""
+        ...
+    @property
+    def send(self) -> Self:
+        """the 'send' end of the channel"""
+        ...
+    @property
+    def recv(self) -> Self:
+        """the 'recv' end of the channel"""
+        ...
+    def __eq__(self, other: object) -> bool:
+        """Return self==value."""
+        ...
+    def __ge__(self, other: ChannelID) -> bool:
+        """Return self>=value."""
+        ...
+    def __gt__(self, other: ChannelID) -> bool:
+        """Return self>value."""
+        ...
+    def __hash__(self) -> int:
+        """Return hash(self)."""
+        ...
+    def __index__(self) -> int:
+        """Return self converted to an integer, if self is suitable for use as an index into a list."""
+        ...
+    def __int__(self) -> int:
+        """int(self)"""
+        ...
+    def __le__(self, other: ChannelID) -> bool:
+        """Return self<=value."""
+        ...
+    def __lt__(self, other: ChannelID) -> bool:
+        """Return self<value."""
+        ...
+    def __ne__(self, other: object) -> bool:
+        """Return self!=value."""
+        ...
+
+@final
+class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
+    """
+    ChannelInfo
+
+    A named tuple of a channel's state.
+    """
+    __match_args__: Final = (
+        "open",
+        "closing",
+        "closed",
+        "count",
+        "num_interp_send",
+        "num_interp_send_released",
+        "num_interp_recv",
+        "num_interp_recv_released",
+    )
+    @property
+    def open(self) -> bool:
+        """both ends are open"""
+        ...
+    @property
+    def closing(self) -> bool:
+        """send is closed, recv is non-empty"""
+        ...
+    @property
+    def closed(self) -> bool:
+        """both ends are closed"""
+        ...
+    @property
+    def count(self) -> int:
+        """queued objects"""
+        ...
+    @property
+    def num_interp_send(self) -> int:
+        """interpreters bound to the send end"""
+        ...
+    @property
+    def num_interp_send_released(self) -> int:
+        """interpreters bound to the send end and released"""
+        ...
+    @property
+    def num_interp_recv(self) -> int:
+        """interpreters bound to the send end"""
+        ...
+    @property
+    def num_interp_recv_released(self) -> int:
+        """interpreters bound to the send end and released"""
+        ...
+    @property
+    def num_interp_both(self) -> int:
+        """interpreters bound to both ends"""
+        ...
+    @property
+    def num_interp_both_recv_released(self) -> int:
+        """interpreters bound to both ends and released_from_the recv end"""
+        ...
+    @property
+    def num_interp_both_send_released(self) -> int:
+        """interpreters bound to both ends and released_from_the send end"""
+        ...
+    @property
+    def num_interp_both_released(self) -> int:
+        """interpreters bound to both ends and released_from_both"""
+        ...
+    @property
+    def recv_associated(self) -> bool:
+        """current interpreter is bound to the recv end"""
+        ...
+    @property
+    def recv_released(self) -> bool:
+        """current interpreter *was* bound to the recv end"""
+        ...
+    @property
+    def send_associated(self) -> bool:
+        """current interpreter is bound to the send end"""
+        ...
+    @property
+    def send_released(self) -> bool:
+        """current interpreter *was* bound to the send end"""
+        ...
+
+def create(unboundop: Literal[1, 2, 3]) -> ChannelID:
+    """
+    channel_create(unboundop) -> cid
+
+    Create a new cross-interpreter channel and return a unique generated ID.
+    """
+    ...
+def destroy(cid: SupportsIndex) -> None:
+    """
+    channel_destroy(cid)
+
+    Close and finalize the channel.  Afterward attempts to use the channel
+    will behave as though it never existed.
+    """
+    ...
+def list_all() -> list[ChannelID]:
+    """
+    channel_list_all() -> [cid]
+
+    Return the list of all IDs for active channels.
+    """
+    ...
+def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]:
+    """
+    channel_list_interpreters(cid, *, send) -> [id]
+
+    Return the list of all interpreter IDs associated with an end of the channel.
+
+    The 'send' argument should be a boolean indicating whether to use the send or
+    receive end.
+    """
+    ...
+def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None:
+    """
+    channel_send(cid, obj, *, blocking=True, timeout=None)
+
+    Add the object's data to the channel's queue.
+    By default this waits for the object to be received.
+    """
+    ...
+def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None:
+    """
+    channel_send_buffer(cid, obj, *, blocking=True, timeout=None)
+
+    Add the object's buffer to the channel's queue.
+    By default this waits for the object to be received.
+    """
+    ...
+def recv(cid: SupportsIndex, default: object = ...) -> tuple[Any, Literal[1, 2, 3]]:
+    """
+    channel_recv(cid, [default]) -> (obj, unboundop)
+
+    Return a new object from the data at the front of the channel's queue.
+
+    If there is nothing to receive then raise ChannelEmptyError, unless
+    a default value is provided.  In that case return it.
+    """
+    ...
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None:
+    """
+    channel_close(cid, *, send=None, recv=None, force=False)
+
+    Close the channel for all interpreters.
+
+    If the channel is empty then the keyword args are ignored and both
+    ends are immediately closed.  Otherwise, if 'force' is True then
+    all queued items are released and both ends are immediately
+    closed.
+
+    If the channel is not empty *and* 'force' is False then following
+    happens:
+
+     * recv is True (regardless of send):
+       - raise ChannelNotEmptyError
+     * recv is None and send is None:
+       - raise ChannelNotEmptyError
+     * send is True and recv is not True:
+       - fully close the 'send' end
+       - close the 'recv' end to interpreters not already receiving
+       - fully close it once empty
+
+    Closing an already closed channel results in a ChannelClosedError.
+
+    Once the channel's ID has no more ref counts in any interpreter
+    the channel will be destroyed.
+    """
+    ...
+def get_count(cid: SupportsIndex) -> int:
+    """
+    get_count(cid)
+
+    Return the number of items in the channel.
+    """
+    ...
+def get_info(cid: SupportsIndex) -> ChannelInfo:
+    """
+    get_info(cid)
+
+    Return details about the channel.
+    """
+    ...
+def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]:
+    """
+    get_channel_defaults(cid)
+
+    Return the channel's default values, set when it was created.
+    """
+    ...
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None:
+    """
+    channel_release(cid, *, send=None, recv=None, force=True)
+
+    Close the channel for the current interpreter.  'send' and 'recv'
+    (bool) may be used to indicate the ends to close.  By default both
+    ends are closed.  Closing an already closed end is a noop.
+    """
+    ...

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

@@ -1,16 +1,100 @@
-from typing import Any, SupportsIndex
-
-class QueueError(RuntimeError): ...
-class QueueNotFoundError(QueueError): ...
-
-def bind(qid: SupportsIndex) -> None: ...
-def create(maxsize: SupportsIndex, fmt: SupportsIndex) -> int: ...
-def destroy(qid: SupportsIndex) -> None: ...
-def get(qid: SupportsIndex) -> tuple[Any, int]: ...
-def get_count(qid: SupportsIndex) -> int: ...
-def get_maxsize(qid: SupportsIndex) -> int: ...
-def get_queue_defaults(qid: SupportsIndex) -> tuple[int]: ...
-def is_full(qid: SupportsIndex) -> bool: ...
-def list_all() -> list[tuple[int, int]]: ...
-def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex) -> None: ...
-def release(qid: SupportsIndex) -> None: ...
+"""
+This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
+
+from typing import Any, SupportsIndex
+
+class QueueError(RuntimeError):
+    """Indicates that a queue-related error happened."""
+    ...
+class QueueNotFoundError(QueueError): ...
+
+def bind(qid: SupportsIndex) -> None:
+    """
+    bind(qid)
+
+    Take a reference to the identified queue.
+    The queue is not destroyed until there are no references left.
+    """
+    ...
+def create(maxsize: SupportsIndex, fmt: SupportsIndex) -> int:
+    """
+    create(maxsize, fmt, unboundop) -> qid
+
+    Create a new cross-interpreter queue and return its unique generated ID.
+    It is a new reference as though bind() had been called on the queue.
+
+    The caller is responsible for calling destroy() for the new queue
+    before the runtime is finalized.
+    """
+    ...
+def destroy(qid: SupportsIndex) -> None:
+    """
+    destroy(qid)
+
+    Clear and destroy the queue.  Afterward attempts to use the queue
+    will behave as though it never existed.
+    """
+    ...
+def get(qid: SupportsIndex) -> tuple[Any, int]:
+    """
+    get(qid) -> (obj, fmt)
+
+    Return a new object from the data at the front of the queue.
+    The object's format is also returned.
+
+    If there is nothing to receive then raise QueueEmpty.
+    """
+    ...
+def get_count(qid: SupportsIndex) -> int:
+    """
+    get_count(qid)
+
+    Return the number of items in the queue.
+    """
+    ...
+def get_maxsize(qid: SupportsIndex) -> int:
+    """
+    get_maxsize(qid)
+
+    Return the maximum number of items in the queue.
+    """
+    ...
+def get_queue_defaults(qid: SupportsIndex) -> tuple[int]:
+    """
+    get_queue_defaults(qid)
+
+    Return the queue's default values, set when it was created.
+    """
+    ...
+def is_full(qid: SupportsIndex) -> bool:
+    """
+    is_full(qid)
+
+    Return true if the queue has a maxsize and has reached it.
+    """
+    ...
+def list_all() -> list[tuple[int, int]]:
+    """
+    list_all() -> [(qid, fmt)]
+
+    Return the list of IDs for all queues.
+    Each corresponding default format is also included.
+    """
+    ...
+def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex) -> None:
+    """
+    put(qid, obj, fmt)
+
+    Add the object's data to the queue.
+    """
+    ...
+def release(qid: SupportsIndex) -> None:
+    """
+    release(qid)
+
+    Release a reference to the queue.
+    The queue is destroyed once there are no references left.
+    """
+    ...