basedpyright 1.36.2 → 1.37.0-961d59bacff1958014fe4e9ed2ef3116fe2266e2

package/dist/typeshed-fallback/stubs/seaborn/seaborn/_core/typing.pyi

@@ -10,8 +10,6 @@ from pandas import DataFrame, Index, Series, Timedelta, Timestamp
 
 @type_check_only
 class SupportsDataFrame(Protocol):
-    # `__dataframe__` should return pandas.core.interchange.dataframe_protocol.DataFrame
-    # but this class needs to be defined as a Protocol, not as an ABC.
     def __dataframe__(self, nan_as_null: bool = ..., allow_copy: bool = ...): ...
 
 ColumnName: TypeAlias = str | bytes | date | datetime | timedelta | bool | complex | Timestamp | Timedelta

package/dist/typeshed-fallback/stubs/seaborn/seaborn/categorical.pyi

@@ -27,7 +27,7 @@ def boxplot(
     dodge: bool | Literal["auto"] = "auto",
     width: float = 0.8,
     gap: float = 0,
-    whis: float = 1.5,
+    whis: float | tuple[float, float] = 1.5,
     linecolor: ColorType = "auto",
     linewidth: float | None = None,
     fliersize: float | None = None,

package/dist/typeshed-fallback/stubs/setuptools/setuptools/__init__.pyi

@@ -1,10 +1,12 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, StrPath
 from abc import abstractmethod
-from collections.abc import Mapping, Sequence
-from typing import Any, Literal, TypedDict, TypeVar, overload, type_check_only
-from typing_extensions import NotRequired
+from collections.abc import ItemsView, Iterable, Mapping, Sequence
+from typing import Any, Literal, Protocol, TypedDict, TypeVar, overload, type_check_only
+from typing_extensions import Never, NotRequired
 
 from ._distutils.cmd import Command as _Command
+from ._distutils.dist import Distribution as _Distribution
+from ._distutils.extension import Extension as _Extension
 from .command.alias import alias
 from .command.bdist_egg import bdist_egg
 from .command.bdist_rpm import bdist_rpm
@@ -33,6 +35,9 @@ from .extension import Extension as Extension
 from .warnings import SetuptoolsDeprecationWarning as SetuptoolsDeprecationWarning
 
 _CommandT = TypeVar("_CommandT", bound=_Command)
+_DistributionT = TypeVar("_DistributionT", bound=_Distribution, default=Distribution)
+_KT = TypeVar("_KT")
+_VT_co = TypeVar("_VT_co", covariant=True)
 
 __all__ = [
     "setup",
@@ -47,6 +52,24 @@ __all__ = [
 
 __version__: str
 
+# We need any Command subclass to be valid
+# Any: pyright would accept using covariance in __setitem__, but mypy won't let a dict be assignable to this protocol
+# This is unsound, but it's a quirk of setuptools' internals
+@type_check_only
+class _DictLike(Protocol[_KT, _VT_co]):
+    # See note about using _VT_co instead of Any
+    def get(self, key: _KT, default: Any | None = None, /) -> _VT_co | None: ...
+    def items(self) -> ItemsView[_KT, _VT_co]: ...
+    def keys(self) -> Iterable[_KT]: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
+    def __contains__(self, x: object, /) -> bool: ...
+
+@type_check_only
+class _MutableDictLike(_DictLike[_KT, _VT_co], Protocol):
+    # See note about using _VT_co instead of Any
+    def __setitem__(self, key: _KT, value: Any, /) -> None: ...
+    def setdefault(self, key: _KT, default: Any, /) -> _VT_co: ...
+
 @type_check_only
 class _BuildInfo(TypedDict):
     sources: list[str] | tuple[str, ...]
@@ -60,49 +83,83 @@ find_namespace_packages = _Finder.find
 
 def setup(
     *,
-    name: str = ...,
-    version: str = ...,
-    description: str = ...,
-    long_description: str = ...,
-    long_description_content_type: str = ...,
-    author: str = ...,
-    author_email: str = ...,
-    maintainer: str = ...,
-    maintainer_email: str = ...,
-    url: str = ...,
-    download_url: str = ...,
-    packages: list[str] = ...,
-    py_modules: list[str] = ...,
-    scripts: list[str] = ...,
-    ext_modules: Sequence[Extension] = ...,
-    classifiers: list[str] = ...,
-    distclass: type[Distribution] = ...,
-    script_name: str = ...,
-    script_args: list[str] = ...,
-    options: Mapping[str, Incomplete] = ...,
-    license: str = ...,
-    keywords: list[str] | str = ...,
-    platforms: list[str] | str = ...,
-    cmdclass: Mapping[str, type[_Command]] = ...,
-    data_files: list[tuple[str, list[str]]] = ...,
-    package_dir: Mapping[str, str] = ...,
-    obsoletes: list[str] = ...,
-    provides: list[str] = ...,
-    requires: list[str] = ...,
-    command_packages: list[str] = ...,
-    command_options: Mapping[str, Mapping[str, tuple[Incomplete, Incomplete]]] = ...,
-    package_data: Mapping[str, list[str]] = ...,
-    include_package_data: bool = ...,
-    # libraries for `Distribution` or `build_clib`, not `Extension`, `build_ext` or `CCompiler`
-    libraries: list[tuple[str, _BuildInfo]] = ...,
-    headers: list[str] = ...,
-    ext_package: str = ...,
-    include_dirs: list[str] = ...,
-    password: str = ...,
-    fullname: str = ...,
+    # Attributes from distutils.dist.DistributionMetadata.set_*
+    # These take priority over attributes from distutils.dist.DistributionMetadata.__init__
+    keywords: str | Iterable[str] = ...,
+    platforms: str | Iterable[str] = ...,
+    classifiers: str | Iterable[str] = ...,
+    requires: Iterable[str] = ...,
+    provides: Iterable[str] = ...,
+    obsoletes: Iterable[str] = ...,
+    # Attributes from distutils.dist.DistributionMetadata.__init__
+    # These take priority over attributes from distutils.dist.Distribution.__init__
+    name: str | None = None,
+    version: str | None = None,
+    author: str | None = None,
+    author_email: str | None = None,
+    maintainer: str | None = None,
+    maintainer_email: str | None = None,
+    url: str | None = None,
+    license: str | None = None,
+    description: str | None = None,
+    long_description: str | None = None,
+    download_url: str | None = None,
+    # Attributes from distutils.dist.Distribution.__init__ (except self.metadata)
+    # These take priority over attributes from distutils.dist.Distribution.display_option_names
+    verbose: bool = True,
+    dry_run: bool = False,
+    help: bool = False,
+    cmdclass: _MutableDictLike[str, type[_Command]] = {},
+    command_packages: str | list[str] | None = None,
+    script_name: StrPath | None = ...,  # default is actually set in distutils.core.setup
+    script_args: list[str] | None = ...,  # default is actually set in distutils.core.setup
+    command_options: _MutableDictLike[str, _DictLike[str, tuple[str, str]]] = {},
+    packages: list[str] | None = None,
+    package_dir: Mapping[str, str] | None = None,
+    py_modules: list[str] | None = None,
+    libraries: list[tuple[str, _BuildInfo]] | None = None,
+    headers: list[str] | None = None,
+    ext_modules: Sequence[_Extension] | None = None,
+    ext_package: str | None = None,
+    include_dirs: list[str] | None = None,
+    extra_path: Never = ...,  # Deprecated
+    scripts: list[str] | None = None,
+    data_files: list[tuple[str, Sequence[str]]] | None = None,
+    password: str = "",
+    command_obj: _MutableDictLike[str, _Command] = {},
+    have_run: _MutableDictLike[str, bool] = {},
+    # kwargs used directly in distutils.dist.Distribution.__init__
+    options: Mapping[str, Mapping[str, str]] | None = None,
+    licence: Never = ...,  # Deprecated
+    # Attributes from distutils.dist.Distribution.display_option_names
+    # (this can more easily be copied from the `if TYPE_CHECKING` block)
+    help_commands: bool = False,
+    fullname: str | Literal[False] = False,
+    contact: str | Literal[False] = False,
+    contact_email: str | Literal[False] = False,
+    # kwargs used directly in setuptools.dist.Distribution.__init__
+    # and attributes from setuptools.dist.Distribution.__init__
+    package_data: _DictLike[str, list[str]] = {},
+    dist_files: list[tuple[str, str, str]] = [],
+    include_package_data: bool | None = None,
+    exclude_package_data: _DictLike[str, list[str]] | None = None,
+    src_root: str | None = None,
+    dependency_links: list[str] = [],
+    setup_requires: list[str] = [],
+    # From Distribution._DISTUTILS_UNSUPPORTED_METADATA set in Distribution._set_metadata_defaults
+    long_description_content_type: str | None = None,
+    project_urls: _DictLike[Incomplete, Incomplete] = {},
+    provides_extras: _MutableDictLike[Incomplete, Incomplete] = {},
+    license_expression: str | None = None,
+    license_file: Never = ...,  # Deprecated
+    license_files: Iterable[str] | None = None,
+    install_requires: str | Iterable[str] = [],
+    extras_require: _DictLike[Incomplete, Incomplete] = {},
+    # kwargs used directly in distutils.core.setup
+    distclass: type[_DistributionT] = Distribution,  # type: ignore[assignment] # noqa: Y011
     # Custom Distributions could accept more params
     **attrs: Any,
-) -> Distribution: ...
+) -> _DistributionT: ...
 
 class Command(_Command):
     command_consumes_arguments: bool

package/dist/typeshed-fallback/stubs/setuptools/setuptools/_distutils/cmd.pyi

@@ -1,7 +1,7 @@
 from _typeshed import BytesPath, StrOrBytesPath, StrPath, Unused
 from abc import abstractmethod
-from collections.abc import Callable, MutableSequence
-from typing import Any, ClassVar, TypeVar, overload
+from collections.abc import Callable, MutableSequence, Sequence
+from typing import Any, ClassVar, Literal, TypeVar, overload
 from typing_extensions import TypeVarTuple, Unpack
 
 from .dist import Distribution
@@ -84,7 +84,10 @@ class Command:
     def move_file(self, src: StrPath, dst: _StrPathT, level: Unused = 1) -> _StrPathT | str: ...
     @overload
     def move_file(self, src: BytesPath, dst: _BytesPathT, level: Unused = 1) -> _BytesPathT | bytes: ...
-    def spawn(self, cmd: MutableSequence[str], search_path: bool = True, level: Unused = 1) -> None: ...
+    @overload
+    def spawn(self, cmd: Sequence[StrOrBytesPath], search_path: Literal[False], level: Unused = 1) -> None: ...
+    @overload
+    def spawn(self, cmd: MutableSequence[bytes | StrPath], search_path: Literal[True] = True, level: Unused = 1) -> None: ...
     @overload
     def make_archive(
         self,

package/dist/typeshed-fallback/stubs/setuptools/setuptools/_distutils/compilers/C/base.pyi

@@ -1,5 +1,6 @@
-from _typeshed import BytesPath, Incomplete, StrPath, Unused
+from _typeshed import BytesPath, Incomplete, StrOrBytesPath, StrPath, Unused
 from collections.abc import Callable, Iterable, MutableSequence, Sequence
+from subprocess import _ENV
 from typing import ClassVar, Final, Literal, TypeVar, overload
 from typing_extensions import TypeAlias, TypeVarTuple, Unpack
 
@@ -172,7 +173,12 @@ class Compiler:
     def execute(
         self, func: Callable[[Unpack[_Ts]], Unused], args: tuple[Unpack[_Ts]], msg: str | None = None, level: int = 1
     ) -> None: ...
-    def spawn(self, cmd: MutableSequence[bytes | StrPath]) -> None: ...
+    @overload
+    def spawn(self, cmd: Sequence[StrOrBytesPath], *, search_path: Literal[False], env: _ENV | None = None) -> None: ...
+    @overload
+    def spawn(
+        self, cmd: MutableSequence[bytes | StrPath], *, search_path: Literal[True] = True, env: _ENV | None = None
+    ) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
     @overload
     def move_file(self, src: StrPath, dst: _StrPathT) -> _StrPathT | str: ...

package/dist/typeshed-fallback/stubs/setuptools/setuptools/_distutils/compilers/C/msvc.pyi

@@ -1,3 +1,5 @@
+from _typeshed import StrPath
+from collections.abc import Sequence
 from typing import ClassVar, Final
 
 from . import base
@@ -17,3 +19,4 @@ class Compiler(base.Compiler):
     def initialize(self, plat_name: str | None = None) -> None: ...
     @property
     def out_extensions(self) -> dict[str, str]: ...
+    def spawn(self, cmd: Sequence[bytes | StrPath]): ...  # type: ignore[override] # Less params

package/dist/typeshed-fallback/stubs/setuptools/setuptools/_distutils/spawn.pyi

@@ -1,11 +1,21 @@
-from _typeshed import StrPath
-from collections.abc import MutableSequence
+from _typeshed import StrOrBytesPath, StrPath, Unused
+from collections.abc import MutableSequence, Sequence
 from subprocess import _ENV
+from typing import Literal, overload
 
+@overload
+def spawn(
+    cmd: Sequence[StrOrBytesPath],
+    search_path: Literal[False],
+    verbose: Unused = False,
+    dry_run: bool = False,
+    env: _ENV | None = None,
+) -> None: ...
+@overload
 def spawn(
     cmd: MutableSequence[bytes | StrPath],
-    search_path: bool = True,
-    verbose: bool = False,
+    search_path: Literal[True] = True,
+    verbose: Unused = False,
     dry_run: bool = False,
     env: _ENV | None = None,
 ) -> None: ...

package/dist/typeshed-fallback/stubs/simple-websocket/METADATA.toml

@@ -0,0 +1,3 @@
+version = "1.1.*"
+upstream_repository = "https://github.com/miguelgrinberg/simple-websocket"
+requires = ["wsproto"]

package/dist/typeshed-fallback/stubs/simple-websocket/simple_websocket/__init__.pyi

@@ -0,0 +1,3 @@
+from .aiows import AioClient as AioClient, AioServer as AioServer
+from .errors import ConnectionClosed as ConnectionClosed, ConnectionError as ConnectionError
+from .ws import Client as Client, Server as Server

package/dist/typeshed-fallback/stubs/simple-websocket/simple_websocket/aiows.pyi

@@ -0,0 +1,130 @@
+import asyncio
+import socket
+from _typeshed import Incomplete, Unused
+from _typeshed.wsgi import WSGIEnvironment
+from collections.abc import Awaitable, Callable
+from ssl import SSLContext
+from typing import Any, Literal, TypedDict, type_check_only
+
+from wsproto import ConnectionType, WSConnection
+from wsproto.events import Request
+from wsproto.frame_protocol import CloseReason
+
+from .asgi import WebSocketASGI, _SocketDataBase, _SocketDataBytes, _SocketDataProtocol, _SocketDataStr
+
+class AioBase:
+    subprotocol: str | None
+    connection_type: ConnectionType
+    receive_bytes: int
+    ping_interval: float | None
+    max_message_size: int | None
+    pong_received: bool
+    input_buffer: list[bytes | str]
+    incoming_message: bytes | str | None
+    incoming_message_len: int
+    connected: bool
+    is_server: bool
+    close_reason: CloseReason
+    close_message: str
+    rsock: asyncio.StreamReader
+    wsock: asyncio.StreamWriter
+    event: asyncio.Event
+    ws: WSConnection | None
+    task: asyncio.Task[None]
+    def __init__(
+        self,
+        connection_type: ConnectionType | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+    ) -> None: ...
+    async def connect(self) -> None: ...
+    async def handshake(self) -> None: ...
+    # data can be antyhing. a special case is made for `bytes`, anything else is converted to `str`.
+    async def send(self, data: bytes | Any) -> None: ...
+    async def receive(self, timeout: float | None = None) -> bytes | str | None: ...
+    async def close(self, reason: CloseReason | None = None, message: str | None = None) -> None: ...
+    def choose_subprotocol(self, request: Request) -> str | None: ...
+
+@type_check_only
+class _AioServerRequest(TypedDict):
+    # this is `aiohttp.web.Request`
+    aiohttp: Incomplete
+    sock: None
+    headers: None
+
+class AioServer(AioBase):
+    request: _AioServerRequest
+    headers: dict[str, Any]
+    subprotocols: list[str]
+    is_server: Literal[True]
+    mode: str
+    connected: bool
+    def __init__(
+        self,
+        request: _AioServerRequest,
+        subprotocols: list[str] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+    ) -> None: ...
+    @classmethod
+    async def accept(
+        cls,
+        # this is `aiohttp.web.Request`
+        aiohttp=None,
+        asgi: (
+            tuple[
+                WSGIEnvironment,
+                Callable[[], Awaitable[_SocketDataBytes | _SocketDataStr]],
+                Callable[[_SocketDataBase | _SocketDataProtocol | _SocketDataBytes | _SocketDataStr], Awaitable[None]],
+            ]
+            | None
+        ) = None,
+        sock: socket.socket | None = None,
+        headers: dict[str, Any] | None = None,
+        subprotocols: list[str] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+    ) -> WebSocketASGI | AioServer: ...
+    async def handshake(self) -> None: ...
+    def choose_subprotocol(self, request: Request) -> str | None: ...
+
+class AioClient(AioBase):
+    url: str
+    ssl_context: SSLContext | None
+    is_secure: bool
+    host: str
+    port: int
+    path: str
+    subprotocols: list[str]
+    extra_headeers: list[tuple[bytes, bytes]]
+    subprotocol: str | None
+    connected: bool
+    def __init__(
+        self,
+        url: str,
+        subprotocols: list[str] | None = None,
+        headers: dict[str, Any] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        ssl_context: SSLContext | None = None,
+    ) -> None: ...
+    # the source code itself has this override
+    @classmethod
+    async def connect(  # type: ignore[override]
+        cls,
+        url: str,
+        subprotocols: list[str] | None = None,
+        headers: dict[str, Any] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        ssl_context: SSLContext | None = None,
+        thread_class: Unused = None,
+        event_class: Unused = None,
+    ) -> AioClient: ...
+    async def handshake(self) -> None: ...
+    async def close(self, reason: CloseReason | None = None, message: str | None = None) -> None: ...

package/dist/typeshed-fallback/stubs/simple-websocket/simple_websocket/asgi.pyi

@@ -0,0 +1,44 @@
+from _typeshed.wsgi import WSGIEnvironment
+from collections.abc import Awaitable, Callable
+from typing import TypedDict, type_check_only
+
+@type_check_only
+class _SocketDataBase(TypedDict):
+    type: str
+
+@type_check_only
+class _SocketDataProtocol(_SocketDataBase):
+    subprotocol: str | None
+
+@type_check_only
+class _SocketDataStr(_SocketDataBase):
+    text: str
+
+@type_check_only
+class _SocketDataBytes(_SocketDataBase):
+    bytes: bytes
+
+class WebSocketASGI:
+    subprotocols: list[str]
+    subprotocol: str
+    connected: bool
+    # this is set in `close` to `False`
+    conncted: bool
+    def __init__(
+        self,
+        scope: WSGIEnvironment,
+        receive: Callable[[], Awaitable[_SocketDataBytes | _SocketDataStr]],
+        send: Callable[[_SocketDataBase | _SocketDataProtocol | _SocketDataBytes | _SocketDataStr], Awaitable[None]],
+        subprotocols: list[str] | None = None,
+    ) -> None: ...
+    @classmethod
+    async def accept(
+        cls,
+        scope: WSGIEnvironment,
+        receive: Callable[[], Awaitable[_SocketDataBytes | _SocketDataStr]],
+        send: Callable[[_SocketDataBase | _SocketDataProtocol | _SocketDataBytes | _SocketDataStr], Awaitable[None]],
+        subprotocols: list[str] | None = None,
+    ) -> WebSocketASGI: ...
+    async def receive(self) -> bytes | str: ...
+    async def send(self, data: bytes | str) -> None: ...
+    async def close(self) -> None: ...

package/dist/typeshed-fallback/stubs/simple-websocket/simple_websocket/errors.pyi

@@ -0,0 +1,12 @@
+from wsproto.frame_protocol import CloseReason
+
+class SimpleWebsocketError(RuntimeError): ...
+
+class ConnectionError(SimpleWebsocketError):
+    status_code: int | None
+    def __init__(self, status_code: int | None = None) -> None: ...
+
+class ConnectionClosed(SimpleWebsocketError):
+    reason: CloseReason
+    message: str | None
+    def __init__(self, reason: CloseReason = ..., message: str | None = None) -> None: ...

package/dist/typeshed-fallback/stubs/simple-websocket/simple_websocket/ws.pyi

@@ -0,0 +1,136 @@
+import socket
+import threading
+from _typeshed import FileDescriptorLike
+from _typeshed.wsgi import WSGIEnvironment
+from collections.abc import Callable
+from selectors import SelectorKey, _EventMask
+from ssl import SSLContext
+from typing import Any, Protocol, type_check_only
+
+from wsproto import ConnectionType, WSConnection
+from wsproto.events import Request
+from wsproto.frame_protocol import CloseReason
+
+@type_check_only
+class _ThreadClassProtocol(Protocol):
+    name: str
+    # this accepts any callable as the target, like `threading.Thread`
+    def __init__(self, target: Callable[..., Any]) -> None: ...
+    def start(self) -> None: ...
+
+@type_check_only
+class _EventClassProtocol(Protocol):
+    def clear(self) -> None: ...
+    def set(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+
+@type_check_only
+class _SelectorClassProtocol(Protocol):
+    # the signature of `register` here is the same as `selectors._BaseSelectorImpl` from the stdlib
+    def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
+    # the signature of `select` here is the same as `selectors.DefaultSelector` from the stdlib
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
+    def close(self) -> None: ...
+
+class Base:
+    subprotocol: str | None
+    sock: socket.socket | None
+    receive_bytes: int
+    ping_interval: float | None
+    max_message_size: int | None
+    pong_received: bool
+    input_buffer: list[bytes | str]
+    incoming_message: bytes | str | None
+    incoming_message_len: int
+    connected: bool
+    is_server: bool
+    close_reason: CloseReason
+    close_message: str | None
+    selector_class: type[_SelectorClassProtocol]
+    event: _EventClassProtocol | threading.Event
+    ws: WSConnection
+    thread: _ThreadClassProtocol | threading.Thread
+    def __init__(
+        self,
+        sock: socket.socket | None = None,
+        connection_type: ConnectionType | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        thread_class: type[_ThreadClassProtocol] | None = None,
+        event_class: type[_EventClassProtocol] | None = None,
+        selector_class: type[_SelectorClassProtocol] | None = None,
+    ) -> None: ...
+    def handshake(self) -> None: ...
+    # data can be antyhing. a special case is made for `bytes`, anything else is converted to `str`.
+    def send(self, data: bytes | Any) -> None: ...
+    def receive(self, timeout: float | None = None) -> bytes | str | None: ...
+    def close(self, reason: CloseReason | None = None, message: str | None = None) -> None: ...
+    def choose_subprotocol(self, request: Request) -> str | None: ...
+
+class Server(Base):
+    environ: WSGIEnvironment
+    subprotocols: list[str]
+    mode: str
+    connected: bool
+    def __init__(
+        self,
+        environ: WSGIEnvironment,
+        subprotocols: list[str] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        thread_class: type[_ThreadClassProtocol] | None = None,
+        event_class: type[_EventClassProtocol] | None = None,
+        selector_class: type[_SelectorClassProtocol] | None = None,
+    ) -> None: ...
+    @classmethod
+    def accept(
+        cls,
+        environ: WSGIEnvironment,
+        subprotocols: list[str] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        thread_class: type[_ThreadClassProtocol] | None = None,
+        event_class: type[_EventClassProtocol] | None = None,
+        selector_class: type[_SelectorClassProtocol] | None = None,
+    ) -> Server: ...
+    def handshake(self) -> None: ...
+    def choose_subprotocol(self, request: Request) -> str | None: ...
+
+class Client(Base):
+    host: str
+    port: int
+    path: str
+    subprotocols: list[str]
+    extra_headeers: list[tuple[bytes, bytes]]
+    subprotocol: str | None
+    connected: bool
+    def __init__(
+        self,
+        url: str,
+        subprotocols: list[str] | None = None,
+        headers: dict[bytes, bytes] | list[tuple[bytes, bytes]] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        ssl_context: SSLContext | None = None,
+        thread_class: type[_ThreadClassProtocol] | None = None,
+        event_class: type[_EventClassProtocol] | None = None,
+    ) -> None: ...
+    @classmethod
+    def connect(
+        cls,
+        url: str,
+        subprotocols: list[str] | None = None,
+        headers: dict[bytes, bytes] | list[tuple[bytes, bytes]] | None = None,
+        receive_bytes: int = 4096,
+        ping_interval: float | None = None,
+        max_message_size: int | None = None,
+        ssl_context: SSLContext | None = None,
+        thread_class: type[_ThreadClassProtocol] | None = None,
+        event_class: type[_EventClassProtocol] | None = None,
+    ) -> Client: ...
+    def handshake(self) -> None: ...
+    def close(self, reason: CloseReason | None = None, message: str | None = None) -> None: ...

package/dist/typeshed-fallback/stubs/tensorflow/METADATA.toml

@@ -0,0 +1,16 @@
+# Using an exact number in the specifier for scripts/sync_protobuf/tensorflow.py
+# When updating, also re-run the script
+version = "~=2.18.0"
+upstream_repository = "https://github.com/tensorflow/tensorflow"
+# requires a version of numpy with a `py.typed` file
+requires = ["numpy>=1.20", "types-protobuf", "types-requests"]
+extra_description = "Partially generated using [mypy-protobuf==3.6.0](https://github.com/nipunn1313/mypy-protobuf/tree/v3.6.0) and libprotoc 27.2 on `tensorflow==2.18.0`."
+partial_stub = true
+
+[tool.stubtest]
+ignore_missing_stub = true
+# TODO: Support/update to keras 3.7
+stubtest_requirements = ["keras==3.6.*"]
+# tensorflow 2.19 doesn't support Python 3.13:
+# https://github.com/tensorflow/tensorflow/issues/78774
+skip = true