basedpyright 1.13.1 → 1.13.2

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

@@ -1,213 +1,213 @@
-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 whitespace which
-        immediately follows a delimiter.  It defaults to False, which
-        means that whitespace 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_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
-"""
-
-import sys
-from _typeshed import SupportsWrite
-from collections.abc import Iterable, Iterator
-from typing import Any, Final, Literal
-from typing_extensions import TypeAlias
-
-__version__: Final[str]
-
-QUOTE_ALL: Literal[1]
-QUOTE_MINIMAL: Literal[0]
-QUOTE_NONE: Literal[3]
-QUOTE_NONNUMERIC: Literal[2]
-if sys.version_info >= (3, 12):
-    QUOTE_STRINGS: Literal[4]
-    QUOTE_NOTNULL: Literal[5]
-
-# Ideally this would be `QUOTE_ALL | QUOTE_MINIMAL | QUOTE_NONE | QUOTE_NONNUMERIC`
-# However, using literals in situations like these can cause false-positives (see #7258)
-_QuotingType: TypeAlias = int
-
-class Error(Exception): ...
-
-class Dialect:
-    """
-    CSV dialect
-
-    The Dialect type records CSV parsing and generation options.
-    """
-    delimiter: str
-    quotechar: str | None
-    escapechar: str | None
-    doublequote: bool
-    skipinitialspace: bool
-    lineterminator: str
-    quoting: _QuotingType
-    strict: bool
-    def __init__(self) -> None: ...
-
-_DialectLike: TypeAlias = str | Dialect | type[Dialect]
-
-class _reader(Iterator[list[str]]):
-    @property
-    def dialect(self) -> Dialect: ...
-    line_num: int
-    def __next__(self) -> list[str]: ...
-
-class _writer:
-    @property
-    def dialect(self) -> Dialect: ...
-    def writerow(self, row: Iterable[Any]) -> Any: ...
-    def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
-
-def writer(
-    csvfile: SupportsWrite[str],
-    dialect: _DialectLike = "excel",
-    *,
-    delimiter: str = ",",
-    quotechar: str | None = '"',
-    escapechar: str | None = None,
-    doublequote: bool = True,
-    skipinitialspace: bool = False,
-    lineterminator: str = "\r\n",
-    quoting: _QuotingType = 0,
-    strict: bool = False,
-) -> _writer:
-    """
-    csv_writer = csv.writer(fileobj [, dialect='excel']
-                                [optional keyword args])
-        for row in sequence:
-            csv_writer.writerow(row)
-
-        [or]
-
-        csv_writer = csv.writer(fileobj [, dialect='excel']
-                                [optional keyword args])
-        csv_writer.writerows(rows)
-
-    The "fileobj" argument can be any object that supports the file API.
-    """
-    ...
-def reader(
-    csvfile: Iterable[str],
-    dialect: _DialectLike = "excel",
-    *,
-    delimiter: str = ",",
-    quotechar: str | None = '"',
-    escapechar: str | None = None,
-    doublequote: bool = True,
-    skipinitialspace: bool = False,
-    lineterminator: str = "\r\n",
-    quoting: _QuotingType = 0,
-    strict: bool = False,
-) -> _reader:
-    """
-    csv_reader = reader(iterable [, dialect='excel']
-                            [optional keyword args])
-        for row in csv_reader:
-            process(row)
-
-    The "iterable" argument can be any object that returns a line
-    of input for each iteration, such as a file object or a list.  The
-    optional "dialect" parameter is discussed below.  The function
-    also accepts optional keyword arguments which override settings
-    provided by the dialect.
-
-    The returned object is an iterator.  Each iteration returns a row
-    of the CSV file (which can span multiple input lines).
-    """
-    ...
-def register_dialect(
-    name: str,
-    dialect: type[Dialect] = ...,
-    *,
-    delimiter: str = ",",
-    quotechar: str | None = '"',
-    escapechar: str | None = None,
-    doublequote: bool = True,
-    skipinitialspace: bool = False,
-    lineterminator: str = "\r\n",
-    quoting: _QuotingType = 0,
-    strict: bool = False,
-) -> None:
-    """
-    Create a mapping from a string name to a dialect class.
-    dialect = csv.register_dialect(name[, dialect[, **fmtparams]])
-    """
-    ...
-def unregister_dialect(name: str) -> None:
-    """
-    Delete the name/dialect mapping associated with a string name.
-    csv.unregister_dialect(name)
-    """
-    ...
-def get_dialect(name: str) -> Dialect:
-    """
-    Return the dialect instance associated with name.
-    dialect = csv.get_dialect(name)
-    """
-    ...
-def list_dialects() -> list[str]:
-    """
-    Return a list of all know dialect names.
-    names = csv.list_dialects()
-    """
-    ...
-def field_size_limit(new_limit: int = ...) -> int:
-    """
-    Sets an upper limit on parsed fields.
-        csv.field_size_limit([limit])
-
-    Returns old limit. If limit is not given, no new limit is set and
-    the old limit is returned
-    """
-    ...
+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 whitespace which
+        immediately follows a delimiter.  It defaults to False, which
+        means that whitespace 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_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
+"""
+
+import sys
+from _typeshed import SupportsWrite
+from collections.abc import Iterable, Iterator
+from typing import Any, Final, Literal
+from typing_extensions import TypeAlias
+
+__version__: Final[str]
+
+QUOTE_ALL: Literal[1]
+QUOTE_MINIMAL: Literal[0]
+QUOTE_NONE: Literal[3]
+QUOTE_NONNUMERIC: Literal[2]
+if sys.version_info >= (3, 12):
+    QUOTE_STRINGS: Literal[4]
+    QUOTE_NOTNULL: Literal[5]
+
+# Ideally this would be `QUOTE_ALL | QUOTE_MINIMAL | QUOTE_NONE | QUOTE_NONNUMERIC`
+# However, using literals in situations like these can cause false-positives (see #7258)
+_QuotingType: TypeAlias = int
+
+class Error(Exception): ...
+
+class Dialect:
+    """
+    CSV dialect
+
+    The Dialect type records CSV parsing and generation options.
+    """
+    delimiter: str
+    quotechar: str | None
+    escapechar: str | None
+    doublequote: bool
+    skipinitialspace: bool
+    lineterminator: str
+    quoting: _QuotingType
+    strict: bool
+    def __init__(self) -> None: ...
+
+_DialectLike: TypeAlias = str | Dialect | type[Dialect]
+
+class _reader(Iterator[list[str]]):
+    @property
+    def dialect(self) -> Dialect: ...
+    line_num: int
+    def __next__(self) -> list[str]: ...
+
+class _writer:
+    @property
+    def dialect(self) -> Dialect: ...
+    def writerow(self, row: Iterable[Any]) -> Any: ...
+    def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+
+def writer(
+    csvfile: SupportsWrite[str],
+    dialect: _DialectLike = "excel",
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> _writer:
+    """
+    csv_writer = csv.writer(fileobj [, dialect='excel']
+                                [optional keyword args])
+        for row in sequence:
+            csv_writer.writerow(row)
+
+        [or]
+
+        csv_writer = csv.writer(fileobj [, dialect='excel']
+                                [optional keyword args])
+        csv_writer.writerows(rows)
+
+    The "fileobj" argument can be any object that supports the file API.
+    """
+    ...
+def reader(
+    csvfile: Iterable[str],
+    dialect: _DialectLike = "excel",
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> _reader:
+    """
+    csv_reader = reader(iterable [, dialect='excel']
+                            [optional keyword args])
+        for row in csv_reader:
+            process(row)
+
+    The "iterable" argument can be any object that returns a line
+    of input for each iteration, such as a file object or a list.  The
+    optional "dialect" parameter is discussed below.  The function
+    also accepts optional keyword arguments which override settings
+    provided by the dialect.
+
+    The returned object is an iterator.  Each iteration returns a row
+    of the CSV file (which can span multiple input lines).
+    """
+    ...
+def register_dialect(
+    name: str,
+    dialect: type[Dialect] = ...,
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> None:
+    """
+    Create a mapping from a string name to a dialect class.
+    dialect = csv.register_dialect(name[, dialect[, **fmtparams]])
+    """
+    ...
+def unregister_dialect(name: str) -> None:
+    """
+    Delete the name/dialect mapping associated with a string name.
+    csv.unregister_dialect(name)
+    """
+    ...
+def get_dialect(name: str) -> Dialect:
+    """
+    Return the dialect instance associated with name.
+    dialect = csv.get_dialect(name)
+    """
+    ...
+def list_dialects() -> list[str]:
+    """
+    Return a list of all know dialect names.
+    names = csv.list_dialects()
+    """
+    ...
+def field_size_limit(new_limit: int = ...) -> int:
+    """
+    Sets an upper limit on parsed fields.
+        csv.field_size_limit([limit])
+
+    Returns old limit. If limit is not given, no new limit is set and
+    the old limit is returned
+    """
+    ...

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

@@ -63,8 +63,7 @@ A_COLOR: int
 A_DIM: int
 A_HORIZONTAL: int
 A_INVIS: int
-if sys.platform != "darwin":
-    A_ITALIC: int
+A_ITALIC: int
 A_LEFT: int
 A_LOW: int
 A_NORMAL: int

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

@@ -0,0 +1,84 @@
+from _typeshed import structseq
+from typing import 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() -> 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 = ...) -> object: ...
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
+def get_info(cid: SupportsIndex) -> ChannelInfo: ...
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...