basedpyright 1.31.5 → 1.31.6

package/dist/typeshed-fallback/stubs/PyMeeus/pymeeus/Venus.pyi

@@ -0,0 +1,44 @@
+from typing import Final
+
+from pymeeus.Angle import Angle
+from pymeeus.Epoch import Epoch
+
+VSOP87_L: Final[list[list[list[float]]]]
+VSOP87_B: Final[list[list[list[float]]]]
+VSOP87_R: Final[list[list[list[float]]]]
+ORBITAL_ELEM: Final[list[list[float]]]
+ORBITAL_ELEM_J2000: Final[list[list[float]]]
+
+class Venus:
+    @staticmethod
+    def geometric_heliocentric_position(epoch: Epoch, tofk5: bool | None = True) -> tuple[Angle, Angle, float]: ...
+    @staticmethod
+    def apparent_heliocentric_position(epoch: Epoch) -> tuple[Angle, Angle, float]: ...
+    @staticmethod
+    def orbital_elements_mean_equinox(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
+    @staticmethod
+    def orbital_elements_j2000(epoch: Epoch) -> tuple[Angle, float, float, Angle, Angle, Angle]: ...
+    @staticmethod
+    def geocentric_position(epoch: Epoch) -> tuple[Angle, Angle, Angle]: ...
+    @staticmethod
+    def inferior_conjunction(epoch: Epoch) -> Epoch: ...
+    @staticmethod
+    def superior_conjunction(epoch: Epoch) -> Epoch: ...
+    @staticmethod
+    def western_elongation(epoch: Epoch) -> tuple[Epoch, Angle]: ...
+    @staticmethod
+    def eastern_elongation(epoch: Epoch) -> tuple[Epoch, Angle]: ...
+    @staticmethod
+    def station_longitude_1(epoch: Epoch) -> Epoch: ...
+    @staticmethod
+    def station_longitude_2(epoch: Epoch) -> Epoch: ...
+    @staticmethod
+    def perihelion_aphelion(epoch: Epoch, perihelion: bool | None = True) -> Epoch: ...
+    @staticmethod
+    def passage_nodes(epoch: Epoch, ascending: bool = True) -> tuple[Epoch, float]: ...
+    @staticmethod
+    def illuminated_fraction(epoch: Epoch) -> float: ...
+    @staticmethod
+    def magnitude(sun_dist: float, earth_dist: float, phase_angle: float | Angle) -> float: ...
+
+def main() -> None: ...

package/dist/typeshed-fallback/stubs/PyMeeus/pymeeus/base.pyi

@@ -0,0 +1,8 @@
+from typing import Final, Literal
+
+TOL: Final = 1e-10
+
+def machine_accuracy() -> tuple[float, int]: ...
+def get_ordinal_suffix(ordinal: float) -> Literal["st", "nd", "rd", "th"]: ...
+def iint(number: float) -> int: ...
+def main() -> None: ...

package/dist/typeshed-fallback/stubs/PyMySQL/pymysql/connections.pyi

@@ -1,15 +1,27 @@
-from _typeshed import FileDescriptorOrPath, Incomplete
-from collections.abc import Mapping
-from socket import socket as _socket
-from ssl import _PasswordType
-from typing import AnyStr, Generic, TypeVar, overload
-from typing_extensions import Self, deprecated
+from _typeshed import FileDescriptorOrPath, Incomplete, Unused
+from collections.abc import Callable, Mapping
+from socket import _Address, socket as _socket
+from ssl import SSLContext, _PasswordType
+from typing import Any, AnyStr, Generic, overload
+from typing_extensions import Self, TypeVar, deprecated
 
 from .charset import charset_by_id as charset_by_id, charset_by_name as charset_by_name
 from .constants import CLIENT as CLIENT, COMMAND as COMMAND, FIELD_TYPE as FIELD_TYPE, SERVER_STATUS as SERVER_STATUS
 from .cursors import Cursor
+from .err import (
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+)
 
-_C = TypeVar("_C", bound=Cursor)
+_C = TypeVar("_C", bound=Cursor, default=Cursor)
 _C2 = TypeVar("_C2", bound=Cursor)
 
 SSL_ENABLED: bool
@@ -23,121 +35,123 @@ def dump_packet(data): ...
 def _lenenc_int(i: int) -> bytes: ...
 
 class Connection(Generic[_C]):
-    ssl: Incomplete
-    host: Incomplete
-    port: Incomplete
-    user: Incomplete
-    password: Incomplete
-    db: Incomplete
-    unix_socket: Incomplete
+    ssl: bool
+    host: str
+    port: int
+    user: str | bytes | None
+    password: bytes
+    db: str | bytes | None
+    unix_socket: _Address | None
     charset: str
     collation: str | None
-    bind_address: Incomplete
-    use_unicode: Incomplete
-    client_flag: Incomplete
-    cursorclass: Incomplete
-    connect_timeout: Incomplete
-    messages: Incomplete
-    encoders: Incomplete
-    decoders: Incomplete
-    host_info: Incomplete
-    sql_mode: Incomplete
-    init_command: Incomplete
+    bind_address: str | None
+    use_unicode: bool
+    client_flag: int
+    cursorclass: type[_C]
+    connect_timeout: float | None
+    host_info: str
+    sql_mode: str | None
+    init_command: str | None
     max_allowed_packet: int
-    server_public_key: bytes
+    server_public_key: bytes | None
+    encoding: str
+    autocommit_mode: bool | None
+    encoders: dict[type[Any], Callable[[Any], str]]  # argument type depends on the key
+    decoders: dict[int, Callable[[str], Any]]  # return type depends on the key
+
     @overload
     def __init__(
-        self: Connection[Cursor],  # different between overloads
+        self,
         *,
+        user: str | bytes | None = None,
+        password: str | bytes = "",
         host: str | None = None,
-        user=None,
-        password: str = "",
-        database=None,
+        database: str | bytes | None = None,
+        unix_socket: _Address | None = None,
         port: int = 0,
-        unix_socket=None,
         charset: str = "",
         collation: str | None = None,
-        sql_mode=None,
-        read_default_file=None,
-        conv=None,
-        use_unicode: bool | None = True,
+        sql_mode: str | None = None,
+        read_default_file: str | None = None,
+        conv: dict[int | type[Any], Callable[[Any], str] | Callable[[str], Any]] | None = None,
+        use_unicode: bool = True,
         client_flag: int = 0,
-        cursorclass: None = None,  # different between overloads
-        init_command=None,
-        connect_timeout: int | None = 10,
-        ssl: Mapping[Incomplete, Incomplete] | None = None,
-        ssl_ca=None,
-        ssl_cert=None,
-        ssl_disabled=None,
-        ssl_key=None,
-        ssl_key_password: _PasswordType | None = None,
-        ssl_verify_cert=None,
-        ssl_verify_identity=None,
-        read_default_group=None,
-        compress=None,
-        named_pipe=None,
+        cursorclass: type[_C] = ...,
+        init_command: str | None = None,
+        connect_timeout: float = 10,
+        read_default_group: str | None = None,
         autocommit: bool | None = False,
-        db=None,
-        passwd=None,
-        local_infile: Incomplete | None = False,
-        max_allowed_packet: int = 16777216,
-        defer_connect: bool | None = False,
-        auth_plugin_map: Mapping[Incomplete, Incomplete] | None = None,
+        local_infile: bool = False,
+        max_allowed_packet: int = 16_777_216,
+        defer_connect: bool = False,
+        auth_plugin_map: dict[str, Callable[[Connection[Any]], Any]] | None = None,
         read_timeout: float | None = None,
         write_timeout: float | None = None,
-        bind_address=None,
-        binary_prefix: bool | None = False,
-        program_name=None,
+        bind_address: str | None = None,
+        binary_prefix: bool = False,
+        program_name: str | None = None,
         server_public_key: bytes | None = None,
+        ssl: dict[str, Incomplete] | SSLContext | None = None,
+        ssl_ca: str | None = None,
+        ssl_cert: str | None = None,
+        ssl_disabled: bool | None = None,
+        ssl_key: str | None = None,
+        ssl_key_password: _PasswordType | None = None,
+        ssl_verify_cert: bool | None = None,
+        ssl_verify_identity: bool | None = None,
+        compress: Unused = None,
+        named_pipe: Unused = None,
+        # different between overloads:
+        passwd: None = None,  # deprecated
+        db: None = None,  # deprecated
     ) -> None: ...
     @overload
+    @deprecated("'passwd' and 'db' arguments are deprecated. Use 'password' and 'database' instead.")
     def __init__(
-        # different between overloads:
-        self: Connection[_C],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        self,
         *,
+        user: str | bytes | None = None,
+        password: str | bytes = "",
         host: str | None = None,
-        user=None,
-        password: str = "",
-        database=None,
+        database: str | bytes | None = None,
+        unix_socket: _Address | None = None,
         port: int = 0,
-        unix_socket=None,
         charset: str = "",
         collation: str | None = None,
-        sql_mode=None,
-        read_default_file=None,
-        conv=None,
-        use_unicode: bool | None = True,
+        sql_mode: str | None = None,
+        read_default_file: str | None = None,
+        conv: dict[int | type[Any], Callable[[Any], str] | Callable[[str], Any]] | None = None,
+        use_unicode: bool = True,
         client_flag: int = 0,
-        cursorclass: type[_C] = ...,  # different between overloads
-        init_command=None,
-        connect_timeout: int | None = 10,
-        ssl: Mapping[Incomplete, Incomplete] | None = None,
-        ssl_ca=None,
-        ssl_cert=None,
-        ssl_disabled=None,
-        ssl_key=None,
-        ssl_verify_cert=None,
-        ssl_verify_identity=None,
-        read_default_group=None,
-        compress=None,
-        named_pipe=None,
+        cursorclass: type[_C] = ...,
+        init_command: str | None = None,
+        connect_timeout: float = 10,
+        read_default_group: str | None = None,
         autocommit: bool | None = False,
-        db=None,
-        passwd=None,
-        local_infile: Incomplete | None = False,
-        max_allowed_packet: int = 16777216,
-        defer_connect: bool | None = False,
-        auth_plugin_map: Mapping[Incomplete, Incomplete] | None = None,
+        local_infile: bool = False,
+        max_allowed_packet: int = 16_777_216,
+        defer_connect: bool = False,
+        auth_plugin_map: dict[str, Callable[[Connection[Any]], Any]] | None = None,
         read_timeout: float | None = None,
         write_timeout: float | None = None,
-        bind_address=None,
-        binary_prefix: bool | None = False,
-        program_name=None,
+        bind_address: str | None = None,
+        binary_prefix: bool = False,
+        program_name: str | None = None,
         server_public_key: bytes | None = None,
+        ssl: dict[str, Incomplete] | SSLContext | None = None,
+        ssl_ca: str | None = None,
+        ssl_cert: str | None = None,
+        ssl_disabled: bool | None = None,
+        ssl_key: str | None = None,
+        ssl_key_password: _PasswordType | None = None,
+        ssl_verify_cert: bool | None = None,
+        ssl_verify_identity: bool | None = None,
+        compress: Unused = None,
+        named_pipe: Unused = None,
+        # different between overloads:
+        passwd: str | bytes | None = None,  # deprecated
+        db: str | bytes | None = None,  # deprecated
     ) -> None: ...
-    socket: Incomplete
-    rfile: Incomplete
-    wfile: Incomplete
     def close(self) -> None: ...
     @property
     def open(self) -> bool: ...
@@ -148,7 +162,7 @@ class Connection(Generic[_C]):
     def begin(self) -> None: ...
     def rollback(self) -> None: ...
     def select_db(self, db) -> None: ...
-    def escape(self, obj, mapping: Mapping[Incomplete, Incomplete] | None = None): ...
+    def escape(self, obj, mapping: Mapping[str, Incomplete] | None = None): ...
     def literal(self, obj): ...
     def escape_string(self, s: AnyStr) -> AnyStr: ...
     @overload
@@ -169,35 +183,36 @@ class Connection(Generic[_C]):
     def insert_id(self): ...
     def thread_id(self): ...
     def character_set_name(self): ...
-    def get_host_info(self): ...
+    def get_host_info(self) -> str: ...
     def get_proto_info(self): ...
     def get_server_info(self): ...
     def show_warnings(self): ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *exc_info: object) -> None: ...
-    Warning: Incomplete
-    Error: Incomplete
-    InterfaceError: Incomplete
-    DatabaseError: Incomplete
-    DataError: Incomplete
-    OperationalError: Incomplete
-    IntegrityError: Incomplete
-    InternalError: Incomplete
-    ProgrammingError: Incomplete
-    NotSupportedError: Incomplete
+    Warning: type[Warning]
+    Error: type[Error]
+    InterfaceError: type[InterfaceError]
+    DatabaseError: type[DatabaseError]
+    DataError: type[DataError]
+    OperationalError: type[OperationalError]
+    IntegrityError: type[IntegrityError]
+    InternalError: type[InternalError]
+    ProgrammingError: type[ProgrammingError]
+    NotSupportedError: type[NotSupportedError]
 
 class MySQLResult:
-    connection: Incomplete
-    affected_rows: Incomplete
-    insert_id: Incomplete
-    server_status: Incomplete
-    warning_count: Incomplete
-    message: Incomplete
-    field_count: Incomplete
+    connection: Connection[Any] | None
+    affected_rows: int | None
+    insert_id: int | None
+    server_status: int | None
+    warning_count: int
+    message: str | None
+    field_count: int
     description: Incomplete
     rows: Incomplete
-    has_next: Incomplete
-    def __init__(self, connection: Connection[Incomplete]) -> None: ...
+    has_next: bool | None
+    unbuffered_active: bool
+    def __init__(self, connection: Connection[Any]) -> None: ...
     def __del__(self) -> None: ...
     first_packet: Incomplete
     def read(self) -> None: ...
@@ -205,6 +220,6 @@ class MySQLResult:
 
 class LoadLocalFile:
     filename: FileDescriptorOrPath
-    connection: Connection[Incomplete]
-    def __init__(self, filename: FileDescriptorOrPath, connection: Connection[Incomplete]) -> None: ...
+    connection: Connection[Any]
+    def __init__(self, filename: FileDescriptorOrPath, connection: Connection[Any]) -> None: ...
     def send_data(self) -> None: ...

package/dist/typeshed-fallback/stubs/PyMySQL/pymysql/cursors.pyi

@@ -45,7 +45,7 @@ class DictCursorMixin:
 
 class SSCursor(Cursor):
     def __del__(self) -> None: ...
-    def read_next(self): ...
+    def read_next(self) -> tuple[Any, ...] | None: ...
     def fetchall(self) -> list[tuple[Any, ...]]: ...  # type: ignore[override]
     def fetchall_unbuffered(self) -> Iterator[tuple[Any, ...]]: ...
     def scroll(self, value: int, mode: str = "relative") -> None: ...
@@ -54,3 +54,4 @@ class DictCursor(DictCursorMixin, Cursor): ...  # type: ignore[misc]
 
 class SSDictCursor(DictCursorMixin, SSCursor):  # type: ignore[misc]
     def fetchall_unbuffered(self) -> Iterator[dict[str, Any]]: ...  # type: ignore[override]
+    def read_next(self) -> dict[str, Any] | None: ...  # type: ignore[override]

package/dist/typeshed-fallback/stubs/PyMySQL/pymysql/protocol.pyi

@@ -11,6 +11,7 @@ UNSIGNED_INT64_COLUMN: Final[int]
 def dump_packet(data) -> None: ...
 
 class MysqlPacket:
+    __slots__ = ("_position", "_data")
     def __init__(self, data, encoding) -> None: ...
     def get_all_data(self): ...
     def read(self, size): ...

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

@@ -0,0 +1,2 @@
+version = "1.7.1"
+upstream_repository = "https://github.com/Anorov/PySocks"

package/dist/typeshed-fallback/stubs/PySocks/socks.pyi

@@ -0,0 +1,143 @@
+import logging
+import socket
+import types
+from _typeshed import ReadableBuffer
+from collections.abc import Callable, Iterable, Mapping
+from typing import Final, TypeVar, overload
+from typing_extensions import ParamSpec, TypeAlias
+
+__version__: Final[str]
+
+log: logging.Logger  # undocumented
+
+_ProxyType: TypeAlias = int
+
+PROXY_TYPE_SOCKS4: Final[_ProxyType]
+SOCKS4: Final[_ProxyType]
+PROXY_TYPE_SOCKS5: Final[_ProxyType]
+SOCKS5: Final[_ProxyType]
+PROXY_TYPE_HTTP: Final[_ProxyType]
+HTTP: Final[_ProxyType]
+
+PROXY_TYPES: Final[dict[str, _ProxyType]]
+PRINTABLE_PROXY_TYPES: Final[dict[_ProxyType, str]]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+def set_self_blocking(function: Callable[_P, _T]) -> Callable[_P, _T]: ...  # undocumented
+
+class ProxyError(IOError):
+    msg: str
+    socket_err: socket.error
+    def __init__(self, msg: str, socket_err: socket.error | None = None) -> None: ...
+
+class GeneralProxyError(ProxyError): ...
+class ProxyConnectionError(ProxyError): ...
+class SOCKS5AuthError(ProxyError): ...
+class SOCKS5Error(ProxyError): ...
+class SOCKS4Error(ProxyError): ...
+class HTTPError(ProxyError): ...
+
+SOCKS4_ERRORS: Final[Mapping[int, str]]
+SOCKS5_ERRORS: Final[Mapping[int, str]]
+DEFAULT_PORTS: Final[Mapping[_ProxyType, int]]
+
+_DefaultProxy: TypeAlias = tuple[_ProxyType | None, str | None, int | None, bool, bytes | None, bytes | None]
+
+def set_default_proxy(
+    proxy_type: _ProxyType | None = None,
+    addr: str | None = None,
+    port: int | None = None,
+    rdns: bool = True,
+    username: str | None = None,
+    password: str | None = None,
+) -> None: ...
+def setdefaultproxy(
+    proxy_type: _ProxyType | None = None,
+    addr: str | None = None,
+    port: int | None = None,
+    rdns: bool = True,
+    username: str | None = None,
+    password: str | None = None,
+    *,
+    proxytype: _ProxyType = ...,
+) -> None: ...
+def get_default_proxy() -> _DefaultProxy | None: ...
+
+getdefaultproxy = get_default_proxy
+
+def wrap_module(module: types.ModuleType) -> None: ...
+
+wrapmodule = wrap_module
+
+_Endpoint: TypeAlias = tuple[str, int]
+
+def create_connection(
+    dest_pair: _Endpoint,
+    timeout: int | None = None,
+    source_address: _Endpoint | None = None,
+    proxy_type: _ProxyType | None = None,
+    proxy_addr: str | None = None,
+    proxy_port: int | None = None,
+    proxy_rdns: bool = True,
+    proxy_username: str | None = None,
+    proxy_password: str | None = None,
+    socket_options: (
+        Iterable[tuple[int, int, int | ReadableBuffer] | tuple[int, int, None, int]] | None
+    ) = None,  # values passing to `socket.setsockopt` method
+) -> socksocket: ...
+
+class _BaseSocket(socket.socket):  # undocumented
+    ...
+
+class socksocket(_BaseSocket):
+    default_proxy: _DefaultProxy | None  # undocumented
+    proxy: _DefaultProxy  # undocumented
+    proxy_sockname: _Endpoint | None  # undocumented
+    proxy_peername: _Endpoint | None  # undocumented
+    def __init__(
+        self, family: socket.AddressFamily = ..., type: socket.SocketKind = ..., proto: int = 0, fileno: int | None = None
+    ) -> None: ...
+    def settimeout(self, timeout: float | None) -> None: ...
+    def gettimeout(self) -> float | None: ...
+    def setblocking(self, v: bool) -> None: ...
+    def set_proxy(
+        self,
+        proxy_type: _ProxyType | None = None,
+        addr: str | None = None,
+        port: int | None = None,
+        rdns: bool = True,
+        username: str | None = None,
+        password: str | None = None,
+    ) -> None: ...
+    def setproxy(
+        self,
+        proxy_type: _ProxyType | None = None,
+        addr: str | None = None,
+        port: int | None = None,
+        rdns: bool = True,
+        username: str | None = None,
+        password: str | None = None,
+        *,
+        proxytype: _ProxyType = ...,
+    ) -> None: ...
+    def bind(self, address: socket._Address, /) -> None: ...
+    @overload
+    def sendto(self, bytes: ReadableBuffer, address: socket._Address) -> int: ...
+    @overload
+    def sendto(self, bytes: ReadableBuffer, flags: int, address: socket._Address) -> int: ...
+    def send(self, bytes: ReadableBuffer, flags: int = 0) -> int: ...
+    def recvfrom(self, bufsize: int, flags: int = 0) -> tuple[bytes, _Endpoint]: ...
+    def recv(self, bufsize: int, flags: int = 0) -> bytes: ...
+    def close(self) -> None: ...
+    def get_proxy_sockname(self) -> _Endpoint | None: ...
+    getproxysockname = get_proxy_sockname
+    def get_proxy_peername(self) -> _Endpoint | None: ...
+    getproxypeername = get_proxy_peername
+    def get_peername(self) -> _Endpoint | None: ...
+    getpeername = get_peername
+    @set_self_blocking
+    def connect(self, dest_pair: _Endpoint, catch_errors: bool | None = None) -> None: ...  # type: ignore[override]
+    @set_self_blocking
+    def connect_ex(self, dest_pair: _Endpoint) -> int: ...  # type: ignore[override]

package/dist/typeshed-fallback/stubs/PySocks/sockshandler.pyi

@@ -0,0 +1,102 @@
+import http.client
+import ssl
+import sys
+import urllib.request
+from _typeshed import Incomplete, SupportsKeysAndGetItem
+from typing import Any, TypeVar
+from typing_extensions import override
+
+import socks
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+def merge_dict(a: dict[_K, _V], b: SupportsKeysAndGetItem[_K, _V]) -> dict[_K, _V]: ...  # undocumented
+def is_ip(s: str) -> bool: ...  # undocumented
+
+socks4_no_rdns: set[str]  # undocumented
+
+class SocksiPyConnection(http.client.HTTPConnection):  # undocumented
+    proxyargs: tuple[int, str, int | None, bool, str | None, str | None]
+    sock: socks.socksocket
+    def __init__(
+        self,
+        proxytype: int,
+        proxyaddr: str,
+        proxyport: int | None = None,
+        rdns: bool = True,
+        username: str | None = None,
+        password: str | None = None,
+        host: str | None = None,
+        port: int | None = None,
+        timeout: float | None = ...,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 8192,
+    ) -> None: ...
+    @override
+    def connect(self) -> None: ...
+
+class SocksiPyConnectionS(http.client.HTTPSConnection):  # undocumented
+    proxyargs: tuple[int, str, int | None, bool, str | None, str | None]
+    sock: socks.socksocket
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            proxytype: int,
+            proxyaddr: str,
+            proxyport: int | None = None,
+            rdns: bool = True,
+            username: str | None = None,
+            password: str | None = None,
+            host: str | None = None,
+            port: int | None = None,
+            *,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            context: ssl.SSLContext | None = None,
+            blocksize: int = 8192,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            proxytype: int,
+            proxyaddr: str,
+            proxyport: int | None = None,
+            rdns: bool = True,
+            username: str | None = None,
+            password: str | None = None,
+            host: str | None = None,
+            port: int | None = None,
+            key_file: str | None = None,
+            cert_file: str | None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            context: ssl.SSLContext | None = None,
+            check_hostname: bool | None = None,
+            blocksize: int = 8192,
+        ) -> None: ...
+
+    @override
+    def connect(self) -> None: ...
+
+class SocksiPyHandler(urllib.request.HTTPHandler, urllib.request.HTTPSHandler):
+    args: tuple[Incomplete, ...]  # undocumented
+    kw: dict[str, Incomplete]  # undocumented
+    def __init__(
+        self,
+        proxytype: int,
+        proxyaddr: str,
+        proxyport: int | None = None,
+        rdns: bool = True,
+        username: str | None = None,
+        password: str | None = None,
+        *,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 8192,
+        **kwargs: Any,  # any additional arguments to `SocksiPyConnection` or `SocksiPyConnectionS`
+    ) -> None: ...
+    @override
+    def http_open(self, req: urllib.request.Request) -> http.client.HTTPResponse: ...  # undocumented
+    @override
+    def https_open(self, req: urllib.request.Request) -> http.client.HTTPResponse: ...  # undocumented

package/dist/typeshed-fallback/stubs/PyYAML/yaml/__init__.pyi

@@ -428,6 +428,7 @@ class YAMLObjectMetaclass(type):
     def __init__(cls, name, bases, kwds) -> None: ...
 
 class YAMLObject(metaclass=YAMLObjectMetaclass):
+    __slots__ = ()
     yaml_loader: Any
     yaml_dumper: Any
     yaml_tag: Any