pyre-check-nightly 0.0.101729941099__py3-none-manylinux1_x86_64.whl → 0.0.101730459520__py3-none-manylinux1_x86_64.whl

pyre_check_nightly-0.0.101729941099.data/data/lib/pyre_check/typeshed/stdlib/io.pyi → pyre_check_nightly-0.0.101730459520.data/data/lib/pyre_check/typeshed/stdlib/_io.pyi

@@ -1,56 +1,25 @@
-import abc
 import builtins
 import codecs
 import sys
 from _typeshed import FileDescriptorOrPath, MaybeNone, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator
+from io import BufferedIOBase, RawIOBase, TextIOBase, UnsupportedOperation as UnsupportedOperation
 from os import _Opener
 from types import TracebackType
 from typing import IO, Any, BinaryIO, Final, Generic, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
 from typing_extensions import Self
 
-__all__ = [
-    "BlockingIOError",
-    "open",
-    "open_code",
-    "IOBase",
-    "RawIOBase",
-    "FileIO",
-    "BytesIO",
-    "StringIO",
-    "BufferedIOBase",
-    "BufferedReader",
-    "BufferedWriter",
-    "BufferedRWPair",
-    "BufferedRandom",
-    "TextIOBase",
-    "TextIOWrapper",
-    "UnsupportedOperation",
-    "SEEK_SET",
-    "SEEK_CUR",
-    "SEEK_END",
-]
-
-if sys.version_info >= (3, 11):
-    __all__ += ["DEFAULT_BUFFER_SIZE", "IncrementalNewlineDecoder", "text_encoding"]
-
 _T = TypeVar("_T")
 
 DEFAULT_BUFFER_SIZE: Final = 8192
 
-SEEK_SET: Final = 0
-SEEK_CUR: Final = 1
-SEEK_END: Final = 2
-
 open = builtins.open
 
 def open_code(path: str) -> IO[bytes]: ...
 
 BlockingIOError = builtins.BlockingIOError
 
-class UnsupportedOperation(OSError, ValueError): ...
-
-class IOBase(metaclass=abc.ABCMeta):
+class _IOBase:
     def __iter__(self) -> Iterator[bytes]: ...
     def __next__(self) -> bytes: ...
     def __enter__(self) -> Self: ...
@@ -77,7 +46,7 @@ class IOBase(metaclass=abc.ABCMeta):
     def closed(self) -> bool: ...
     def _checkClosed(self) -> None: ...  # undocumented
 
-class RawIOBase(IOBase):
+class _RawIOBase(_IOBase):
     def readall(self) -> bytes: ...
     # The following methods can return None if the file is in non-blocking mode
     # and no data is available.
@@ -85,7 +54,7 @@ class RawIOBase(IOBase):
     def write(self, b: ReadableBuffer, /) -> int | MaybeNone: ...
     def read(self, size: int = -1, /) -> bytes | MaybeNone: ...
 
-class BufferedIOBase(IOBase):
+class _BufferedIOBase(_IOBase):
     def detach(self) -> RawIOBase: ...
     def readinto(self, buffer: WriteableBuffer, /) -> int: ...
     def write(self, buffer: ReadableBuffer, /) -> int: ...
@@ -93,7 +62,7 @@ class BufferedIOBase(IOBase):
     def read(self, size: int | None = ..., /) -> bytes: ...
     def read1(self, size: int = ..., /) -> bytes: ...
 
-class FileIO(RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+class FileIO(RawIOBase, _RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
     mode: str
     # The type of "name" equals the argument passed in to the constructor,
     # but that can make FileIO incompatible with other I/O types that assume
@@ -104,40 +73,40 @@ class FileIO(RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definit
     ) -> None: ...
     @property
     def closefd(self) -> bool: ...
-    def __enter__(self) -> Self: ...
 
-class BytesIO(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+class BytesIO(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
     def __init__(self, initial_bytes: ReadableBuffer = ...) -> None: ...
     # BytesIO does not contain a "name" field. This workaround is necessary
     # to allow BytesIO sub-classes to add this field, as it is defined
     # as a read-only property on IO[].
     name: Any
-    def __enter__(self) -> Self: ...
     def getvalue(self) -> bytes: ...
     def getbuffer(self) -> memoryview: ...
     def read1(self, size: int | None = -1, /) -> bytes: ...
 
-class BufferedReader(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+class BufferedReader(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
     raw: RawIOBase
-    def __enter__(self) -> Self: ...
-    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
     def peek(self, size: int = 0, /) -> bytes: ...
 
-class BufferedWriter(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+class BufferedWriter(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
     raw: RawIOBase
-    def __enter__(self) -> Self: ...
-    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
     def write(self, buffer: ReadableBuffer, /) -> int: ...
 
-class BufferedRandom(BufferedReader, BufferedWriter):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
-    def __enter__(self) -> Self: ...
+class BufferedRandom(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    mode: str
+    name: Any
+    raw: RawIOBase
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
     def seek(self, target: int, whence: int = 0, /) -> int: ...  # stubtest needs this
+    def peek(self, size: int = 0, /) -> bytes: ...
 
-class BufferedRWPair(BufferedIOBase):
-    def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = ...) -> None: ...
+class BufferedRWPair(BufferedIOBase, _BufferedIOBase):
+    def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = 8192) -> None: ...
     def peek(self, size: int = ..., /) -> bytes: ...
 
-class TextIOBase(IOBase):
+class _TextIOBase(_IOBase):
     encoding: str
     errors: str | None
     newlines: str | tuple[str, ...] | None
@@ -176,7 +145,7 @@ class _WrappedBuffer(Protocol):
 
 _BufferT_co = TypeVar("_BufferT_co", bound=_WrappedBuffer, default=_WrappedBuffer, covariant=True)
 
-class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+class TextIOWrapper(TextIOBase, _TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
     def __init__(
         self,
         buffer: _BufferT_co,
@@ -190,8 +159,6 @@ class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[m
     @property
     def buffer(self) -> _BufferT_co: ...  # type: ignore[override]
     @property
-    def closed(self) -> bool: ...
-    @property
     def line_buffering(self) -> bool: ...
     @property
     def write_through(self) -> bool: ...
@@ -204,32 +171,30 @@ class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[m
         line_buffering: bool | None = None,
         write_through: bool | None = None,
     ) -> None: ...
-    # These are inherited from TextIOBase, but must exist in the stub to satisfy mypy.
-    def __enter__(self) -> Self: ...
-    def __iter__(self) -> Iterator[str]: ...  # type: ignore[override]
-    def __next__(self) -> str: ...  # type: ignore[override]
-    def writelines(self, lines: Iterable[str], /) -> None: ...  # type: ignore[override]
     def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
-    def readlines(self, hint: int = -1, /) -> list[str]: ...  # type: ignore[override]
     # Equals the "buffer" argument passed in to the constructor.
     def detach(self) -> _BufferT_co: ...  # type: ignore[override]
     # TextIOWrapper's version of seek only supports a limited subset of
     # operations.
     def seek(self, cookie: int, whence: int = 0, /) -> int: ...
 
-class StringIO(TextIOWrapper):
+class StringIO(TextIOBase, _TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
     def __init__(self, initial_value: str | None = ..., newline: str | None = ...) -> None: ...
     # StringIO does not contain a "name" field. This workaround is necessary
     # to allow StringIO sub-classes to add this field, as it is defined
     # as a read-only property on IO[].
     name: Any
     def getvalue(self) -> str: ...
+    @property
+    def line_buffering(self) -> bool: ...
 
-class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
+class IncrementalNewlineDecoder:
     def __init__(self, decoder: codecs.IncrementalDecoder | None, translate: bool, errors: str = ...) -> None: ...
     def decode(self, input: ReadableBuffer | str, final: bool = False) -> str: ...
     @property
     def newlines(self) -> str | tuple[str, ...] | None: ...
+    def getstate(self) -> tuple[bytes, int]: ...
+    def reset(self) -> None: ...
     def setstate(self, state: tuple[bytes, int], /) -> None: ...
 
 if sys.version_info >= (3, 10):

{pyre_check_nightly-0.0.101729941099.data → pyre_check_nightly-0.0.101730459520.data}/data/lib/pyre_check/typeshed/stdlib/_operator.pyi

@@ -1,18 +1,16 @@
 import sys
 from _typeshed import SupportsGetItem
 from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
-from typing import Any, AnyStr, Generic, Protocol, SupportsAbs, SupportsIndex, TypeVar, final, overload
-from typing_extensions import ParamSpec, TypeAlias, TypeIs, TypeVarTuple, Unpack
+from operator import attrgetter as attrgetter, itemgetter as itemgetter, methodcaller as methodcaller
+from typing import Any, AnyStr, Protocol, SupportsAbs, SupportsIndex, TypeVar, overload
+from typing_extensions import ParamSpec, TypeAlias, TypeIs
 
 _R = TypeVar("_R")
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
 _K = TypeVar("_K")
 _V = TypeVar("_V")
 _P = ParamSpec("_P")
-_Ts = TypeVarTuple("_Ts")
 
 # The following protocols return "Any" instead of bool, since the comparison
 # operators can be overloaded to return an arbitrary object. For example,
@@ -92,40 +90,6 @@ def setitem(a: MutableSequence[_T], b: slice, c: Sequence[_T], /) -> None: ...
 @overload
 def setitem(a: MutableMapping[_K, _V], b: _K, c: _V, /) -> None: ...
 def length_hint(obj: object, default: int = 0, /) -> int: ...
-@final
-class attrgetter(Generic[_T_co]):
-    @overload
-    def __new__(cls, attr: str, /) -> attrgetter[Any]: ...
-    @overload
-    def __new__(cls, attr: str, attr2: str, /) -> attrgetter[tuple[Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, attr2: str, attr3: str, /) -> attrgetter[tuple[Any, Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, attr2: str, attr3: str, attr4: str, /) -> attrgetter[tuple[Any, Any, Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, /, *attrs: str) -> attrgetter[tuple[Any, ...]]: ...
-    def __call__(self, obj: Any, /) -> _T_co: ...
-
-@final
-class itemgetter(Generic[_T_co]):
-    @overload
-    def __new__(cls, item: _T, /) -> itemgetter[_T]: ...
-    @overload
-    def __new__(cls, item1: _T1, item2: _T2, /, *items: Unpack[_Ts]) -> itemgetter[tuple[_T1, _T2, Unpack[_Ts]]]: ...
-    # __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
-    # TypeVar "_KT_contra@SupportsGetItem" is contravariant
-    #   "tuple[int, int]" is incompatible with protocol "SupportsIndex"
-    # preventing [_T_co, ...] instead of [Any, ...]
-    #
-    # A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
-    # https://github.com/python/mypy/issues/14032
-    def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
-
-@final
-class methodcaller:
-    def __init__(self, name: str, /, *args: Any, **kwargs: Any) -> None: ...
-    def __call__(self, obj: Any) -> Any: ...
-
 def iadd(a: Any, b: Any, /) -> Any: ...
 def iand(a: Any, b: Any, /) -> Any: ...
 def iconcat(a: Any, b: Any, /) -> Any: ...

{pyre_check_nightly-0.0.101729941099.data → pyre_check_nightly-0.0.101730459520.data}/data/lib/pyre_check/typeshed/stdlib/_socket.pyi

@@ -1,6 +1,7 @@
 import sys
 from _typeshed import ReadableBuffer, WriteableBuffer
 from collections.abc import Iterable
+from socket import error as error, gaierror as gaierror, herror as herror, timeout as timeout
 from typing import Any, SupportsIndex, overload
 from typing_extensions import TypeAlias
 
@@ -666,18 +667,6 @@ if sys.platform != "win32":
 if sys.platform != "win32" and sys.platform != "darwin":
     IPX_TYPE: int
 
-# ===== Exceptions =====
-
-error = OSError
-
-class herror(error): ...
-class gaierror(error): ...
-
-if sys.version_info >= (3, 10):
-    timeout = TimeoutError
-else:
-    class timeout(error): ...
-
 # ===== Classes =====
 
 class socket:
@@ -687,8 +676,9 @@ class socket:
     def type(self) -> int: ...
     @property
     def proto(self) -> int: ...
+    # F811: "Redefinition of unused `timeout`"
     @property
-    def timeout(self) -> float | None: ...
+    def timeout(self) -> float | None: ...  # noqa: F811
     if sys.platform == "win32":
         def __init__(
             self, family: int = ..., type: int = ..., proto: int = ..., fileno: SupportsIndex | bytes | None = ...
@@ -788,7 +778,9 @@ def inet_ntoa(packed_ip: ReadableBuffer, /) -> str: ...
 def inet_pton(address_family: int, ip_string: str, /) -> bytes: ...
 def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str: ...
 def getdefaulttimeout() -> float | None: ...
-def setdefaulttimeout(timeout: float | None, /) -> None: ...
+
+# F811: "Redefinition of unused `timeout`"
+def setdefaulttimeout(timeout: float | None, /) -> None: ...  # noqa: F811
 
 if sys.platform != "win32":
     def sethostname(name: str, /) -> None: ...

pyre_check_nightly-0.0.101730459520.data/data/lib/pyre_check/typeshed/stdlib/_sqlite3.pyi

@@ -0,0 +1,312 @@
+import sys
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Callable
+from sqlite3 import (
+    Connection as Connection,
+    Cursor as Cursor,
+    DatabaseError as DatabaseError,
+    DataError as DataError,
+    Error as Error,
+    IntegrityError as IntegrityError,
+    InterfaceError as InterfaceError,
+    InternalError as InternalError,
+    NotSupportedError as NotSupportedError,
+    OperationalError as OperationalError,
+    PrepareProtocol as PrepareProtocol,
+    ProgrammingError as ProgrammingError,
+    Row as Row,
+    Warning as Warning,
+)
+from typing import Any, Final, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 11):
+    from sqlite3 import Blob as Blob
+
+_T = TypeVar("_T")
+_ConnectionT = TypeVar("_ConnectionT", bound=Connection)
+_SqliteData: TypeAlias = str | ReadableBuffer | int | float | None
+_Adapter: TypeAlias = Callable[[_T], _SqliteData]
+_Converter: TypeAlias = Callable[[bytes], Any]
+
+PARSE_COLNAMES: Final[int]
+PARSE_DECLTYPES: Final[int]
+SQLITE_ALTER_TABLE: Final[int]
+SQLITE_ANALYZE: Final[int]
+SQLITE_ATTACH: Final[int]
+SQLITE_CREATE_INDEX: Final[int]
+SQLITE_CREATE_TABLE: Final[int]
+SQLITE_CREATE_TEMP_INDEX: Final[int]
+SQLITE_CREATE_TEMP_TABLE: Final[int]
+SQLITE_CREATE_TEMP_TRIGGER: Final[int]
+SQLITE_CREATE_TEMP_VIEW: Final[int]
+SQLITE_CREATE_TRIGGER: Final[int]
+SQLITE_CREATE_VIEW: Final[int]
+SQLITE_CREATE_VTABLE: Final[int]
+SQLITE_DELETE: Final[int]
+SQLITE_DENY: Final[int]
+SQLITE_DETACH: Final[int]
+SQLITE_DONE: Final[int]
+SQLITE_DROP_INDEX: Final[int]
+SQLITE_DROP_TABLE: Final[int]
+SQLITE_DROP_TEMP_INDEX: Final[int]
+SQLITE_DROP_TEMP_TABLE: Final[int]
+SQLITE_DROP_TEMP_TRIGGER: Final[int]
+SQLITE_DROP_TEMP_VIEW: Final[int]
+SQLITE_DROP_TRIGGER: Final[int]
+SQLITE_DROP_VIEW: Final[int]
+SQLITE_DROP_VTABLE: Final[int]
+SQLITE_FUNCTION: Final[int]
+SQLITE_IGNORE: Final[int]
+SQLITE_INSERT: Final[int]
+SQLITE_OK: Final[int]
+SQLITE_PRAGMA: Final[int]
+SQLITE_READ: Final[int]
+SQLITE_RECURSIVE: Final[int]
+SQLITE_REINDEX: Final[int]
+SQLITE_SAVEPOINT: Final[int]
+SQLITE_SELECT: Final[int]
+SQLITE_TRANSACTION: Final[int]
+SQLITE_UPDATE: Final[int]
+adapters: dict[tuple[type[Any], type[Any]], _Adapter[Any]]
+converters: dict[str, _Converter]
+sqlite_version: str
+
+if sys.version_info < (3, 12):
+    version: str
+
+if sys.version_info >= (3, 12):
+    LEGACY_TRANSACTION_CONTROL: Final[int]
+    SQLITE_DBCONFIG_DEFENSIVE: Final[int]
+    SQLITE_DBCONFIG_DQS_DDL: Final[int]
+    SQLITE_DBCONFIG_DQS_DML: Final[int]
+    SQLITE_DBCONFIG_ENABLE_FKEY: Final[int]
+    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: Final[int]
+    SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: Final[int]
+    SQLITE_DBCONFIG_ENABLE_QPSG: Final[int]
+    SQLITE_DBCONFIG_ENABLE_TRIGGER: Final[int]
+    SQLITE_DBCONFIG_ENABLE_VIEW: Final[int]
+    SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: Final[int]
+    SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: Final[int]
+    SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: Final[int]
+    SQLITE_DBCONFIG_RESET_DATABASE: Final[int]
+    SQLITE_DBCONFIG_TRIGGER_EQP: Final[int]
+    SQLITE_DBCONFIG_TRUSTED_SCHEMA: Final[int]
+    SQLITE_DBCONFIG_WRITABLE_SCHEMA: Final[int]
+
+if sys.version_info >= (3, 11):
+    SQLITE_ABORT: Final[int]
+    SQLITE_ABORT_ROLLBACK: Final[int]
+    SQLITE_AUTH: Final[int]
+    SQLITE_AUTH_USER: Final[int]
+    SQLITE_BUSY: Final[int]
+    SQLITE_BUSY_RECOVERY: Final[int]
+    SQLITE_BUSY_SNAPSHOT: Final[int]
+    SQLITE_BUSY_TIMEOUT: Final[int]
+    SQLITE_CANTOPEN: Final[int]
+    SQLITE_CANTOPEN_CONVPATH: Final[int]
+    SQLITE_CANTOPEN_DIRTYWAL: Final[int]
+    SQLITE_CANTOPEN_FULLPATH: Final[int]
+    SQLITE_CANTOPEN_ISDIR: Final[int]
+    SQLITE_CANTOPEN_NOTEMPDIR: Final[int]
+    SQLITE_CANTOPEN_SYMLINK: Final[int]
+    SQLITE_CONSTRAINT: Final[int]
+    SQLITE_CONSTRAINT_CHECK: Final[int]
+    SQLITE_CONSTRAINT_COMMITHOOK: Final[int]
+    SQLITE_CONSTRAINT_FOREIGNKEY: Final[int]
+    SQLITE_CONSTRAINT_FUNCTION: Final[int]
+    SQLITE_CONSTRAINT_NOTNULL: Final[int]
+    SQLITE_CONSTRAINT_PINNED: Final[int]
+    SQLITE_CONSTRAINT_PRIMARYKEY: Final[int]
+    SQLITE_CONSTRAINT_ROWID: Final[int]
+    SQLITE_CONSTRAINT_TRIGGER: Final[int]
+    SQLITE_CONSTRAINT_UNIQUE: Final[int]
+    SQLITE_CONSTRAINT_VTAB: Final[int]
+    SQLITE_CORRUPT: Final[int]
+    SQLITE_CORRUPT_INDEX: Final[int]
+    SQLITE_CORRUPT_SEQUENCE: Final[int]
+    SQLITE_CORRUPT_VTAB: Final[int]
+    SQLITE_EMPTY: Final[int]
+    SQLITE_ERROR: Final[int]
+    SQLITE_ERROR_MISSING_COLLSEQ: Final[int]
+    SQLITE_ERROR_RETRY: Final[int]
+    SQLITE_ERROR_SNAPSHOT: Final[int]
+    SQLITE_FORMAT: Final[int]
+    SQLITE_FULL: Final[int]
+    SQLITE_INTERNAL: Final[int]
+    SQLITE_INTERRUPT: Final[int]
+    SQLITE_IOERR: Final[int]
+    SQLITE_IOERR_ACCESS: Final[int]
+    SQLITE_IOERR_AUTH: Final[int]
+    SQLITE_IOERR_BEGIN_ATOMIC: Final[int]
+    SQLITE_IOERR_BLOCKED: Final[int]
+    SQLITE_IOERR_CHECKRESERVEDLOCK: Final[int]
+    SQLITE_IOERR_CLOSE: Final[int]
+    SQLITE_IOERR_COMMIT_ATOMIC: Final[int]
+    SQLITE_IOERR_CONVPATH: Final[int]
+    SQLITE_IOERR_CORRUPTFS: Final[int]
+    SQLITE_IOERR_DATA: Final[int]
+    SQLITE_IOERR_DELETE: Final[int]
+    SQLITE_IOERR_DELETE_NOENT: Final[int]
+    SQLITE_IOERR_DIR_CLOSE: Final[int]
+    SQLITE_IOERR_DIR_FSYNC: Final[int]
+    SQLITE_IOERR_FSTAT: Final[int]
+    SQLITE_IOERR_FSYNC: Final[int]
+    SQLITE_IOERR_GETTEMPPATH: Final[int]
+    SQLITE_IOERR_LOCK: Final[int]
+    SQLITE_IOERR_MMAP: Final[int]
+    SQLITE_IOERR_NOMEM: Final[int]
+    SQLITE_IOERR_RDLOCK: Final[int]
+    SQLITE_IOERR_READ: Final[int]
+    SQLITE_IOERR_ROLLBACK_ATOMIC: Final[int]
+    SQLITE_IOERR_SEEK: Final[int]
+    SQLITE_IOERR_SHMLOCK: Final[int]
+    SQLITE_IOERR_SHMMAP: Final[int]
+    SQLITE_IOERR_SHMOPEN: Final[int]
+    SQLITE_IOERR_SHMSIZE: Final[int]
+    SQLITE_IOERR_SHORT_READ: Final[int]
+    SQLITE_IOERR_TRUNCATE: Final[int]
+    SQLITE_IOERR_UNLOCK: Final[int]
+    SQLITE_IOERR_VNODE: Final[int]
+    SQLITE_IOERR_WRITE: Final[int]
+    SQLITE_LIMIT_ATTACHED: Final[int]
+    SQLITE_LIMIT_COLUMN: Final[int]
+    SQLITE_LIMIT_COMPOUND_SELECT: Final[int]
+    SQLITE_LIMIT_EXPR_DEPTH: Final[int]
+    SQLITE_LIMIT_FUNCTION_ARG: Final[int]
+    SQLITE_LIMIT_LENGTH: Final[int]
+    SQLITE_LIMIT_LIKE_PATTERN_LENGTH: Final[int]
+    SQLITE_LIMIT_SQL_LENGTH: Final[int]
+    SQLITE_LIMIT_TRIGGER_DEPTH: Final[int]
+    SQLITE_LIMIT_VARIABLE_NUMBER: Final[int]
+    SQLITE_LIMIT_VDBE_OP: Final[int]
+    SQLITE_LIMIT_WORKER_THREADS: Final[int]
+    SQLITE_LOCKED: Final[int]
+    SQLITE_LOCKED_SHAREDCACHE: Final[int]
+    SQLITE_LOCKED_VTAB: Final[int]
+    SQLITE_MISMATCH: Final[int]
+    SQLITE_MISUSE: Final[int]
+    SQLITE_NOLFS: Final[int]
+    SQLITE_NOMEM: Final[int]
+    SQLITE_NOTADB: Final[int]
+    SQLITE_NOTFOUND: Final[int]
+    SQLITE_NOTICE: Final[int]
+    SQLITE_NOTICE_RECOVER_ROLLBACK: Final[int]
+    SQLITE_NOTICE_RECOVER_WAL: Final[int]
+    SQLITE_OK_LOAD_PERMANENTLY: Final[int]
+    SQLITE_OK_SYMLINK: Final[int]
+    SQLITE_PERM: Final[int]
+    SQLITE_PROTOCOL: Final[int]
+    SQLITE_RANGE: Final[int]
+    SQLITE_READONLY: Final[int]
+    SQLITE_READONLY_CANTINIT: Final[int]
+    SQLITE_READONLY_CANTLOCK: Final[int]
+    SQLITE_READONLY_DBMOVED: Final[int]
+    SQLITE_READONLY_DIRECTORY: Final[int]
+    SQLITE_READONLY_RECOVERY: Final[int]
+    SQLITE_READONLY_ROLLBACK: Final[int]
+    SQLITE_ROW: Final[int]
+    SQLITE_SCHEMA: Final[int]
+    SQLITE_TOOBIG: Final[int]
+    SQLITE_WARNING: Final[int]
+    SQLITE_WARNING_AUTOINDEX: Final[int]
+    threadsafety: Final[int]
+
+# Can take or return anything depending on what's in the registry.
+@overload
+def adapt(obj: Any, proto: Any, /) -> Any: ...
+@overload
+def adapt(obj: Any, proto: Any, alt: _T, /) -> Any | _T: ...
+def complete_statement(statement: str) -> bool: ...
+
+if sys.version_info >= (3, 12):
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        cached_statements: int = 128,
+        uri: bool = False,
+        *,
+        autocommit: bool = ...,
+    ) -> Connection: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float,
+        detect_types: int,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None,
+        check_same_thread: bool,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+        *,
+        autocommit: bool = ...,
+    ) -> _ConnectionT: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        *,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+        autocommit: bool = ...,
+    ) -> _ConnectionT: ...
+
+else:
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> Connection: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float,
+        detect_types: int,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None,
+        check_same_thread: bool,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> _ConnectionT: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        *,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> _ConnectionT: ...
+
+def enable_callback_tracebacks(enable: bool, /) -> None: ...
+
+if sys.version_info < (3, 12):
+    # takes a pos-or-keyword argument because there is a C wrapper
+    def enable_shared_cache(do_enable: int) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def register_adapter(type: type[_T], adapter: _Adapter[_T], /) -> None: ...
+    def register_converter(typename: str, converter: _Converter, /) -> None: ...
+
+else:
+    def register_adapter(type: type[_T], caster: _Adapter[_T], /) -> None: ...
+    def register_converter(name: str, converter: _Converter, /) -> None: ...
+
+if sys.version_info < (3, 10):
+    OptimizedUnicode = str