jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/reduction.pyi

@@ -1,90 +0,0 @@
-import pickle
-import sys
-from _typeshed import HasFileno, SupportsWrite, Unused
-from abc import ABCMeta
-from builtins import type as Type  # alias to avoid name clash
-from collections.abc import Callable
-from copyreg import _DispatchTableType
-from multiprocessing import connection
-from pickle import _ReducedType
-from socket import socket
-from typing import Any, Literal
-
-if sys.platform == "win32":
-    __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupHandle", "duplicate", "steal_handle"]
-else:
-    __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupFd", "sendfds", "recvfds"]
-
-HAVE_SEND_HANDLE: bool
-
-class ForkingPickler(pickle.Pickler):
-    dispatch_table: _DispatchTableType
-    def __init__(self, file: SupportsWrite[bytes], protocol: int | None = ...) -> None: ...
-    @classmethod
-    def register(cls, type: Type, reduce: Callable[[Any], _ReducedType]) -> None: ...
-    @classmethod
-    def dumps(cls, obj: Any, protocol: int | None = None) -> memoryview: ...
-    loads = pickle.loads
-
-register = ForkingPickler.register
-
-def dump(obj: Any, file: SupportsWrite[bytes], protocol: int | None = None) -> None: ...
-
-if sys.platform == "win32":
-    def duplicate(
-        handle: int, target_process: int | None = None, inheritable: bool = False, *, source_process: int | None = None
-    ) -> int: ...
-    def steal_handle(source_pid: int, handle: int) -> int: ...
-    def send_handle(conn: connection.PipeConnection, handle: int, destination_pid: int) -> None: ...
-    def recv_handle(conn: connection.PipeConnection) -> int: ...
-
-    class DupHandle:
-        def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...
-        def detach(self) -> int: ...
-
-else:
-    if sys.platform == "darwin":
-        ACKNOWLEDGE: Literal[True]
-    else:
-        ACKNOWLEDGE: Literal[False]
-
-    def recvfds(sock: socket, size: int) -> list[int]: ...
-    def send_handle(conn: HasFileno, handle: int, destination_pid: Unused) -> None: ...
-    def recv_handle(conn: HasFileno) -> int: ...
-    def sendfds(sock: socket, fds: list[int]) -> None: ...
-    def DupFd(fd: int) -> Any: ...  # Return type is really hard to get right
-
-# These aliases are to work around pyright complaints.
-# Pyright doesn't like it when a class object is defined as an alias
-# of a global object with the same name.
-_ForkingPickler = ForkingPickler
-_register = register
-_dump = dump
-_send_handle = send_handle
-_recv_handle = recv_handle
-
-if sys.platform == "win32":
-    _steal_handle = steal_handle
-    _duplicate = duplicate
-    _DupHandle = DupHandle
-else:
-    _sendfds = sendfds
-    _recvfds = recvfds
-    _DupFd = DupFd
-
-class AbstractReducer(metaclass=ABCMeta):
-    ForkingPickler = _ForkingPickler
-    register = _register
-    dump = _dump
-    send_handle = _send_handle
-    recv_handle = _recv_handle
-    if sys.platform == "win32":
-        steal_handle = _steal_handle
-        duplicate = _duplicate
-        DupHandle = _DupHandle
-    else:
-        sendfds = _sendfds
-        recvfds = _recvfds
-        DupFd = _DupFd
-
-    def __init__(self, *args: Unused) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/resource_sharer.pyi

@@ -1,20 +0,0 @@
-import sys
-from socket import socket
-
-__all__ = ["stop"]
-
-if sys.platform == "win32":
-    __all__ += ["DupSocket"]
-
-    class DupSocket:
-        def __init__(self, sock: socket) -> None: ...
-        def detach(self) -> socket: ...
-
-else:
-    __all__ += ["DupFd"]
-
-    class DupFd:
-        def __init__(self, fd: int) -> None: ...
-        def detach(self) -> int: ...
-
-def stop(timeout: float | None = None) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi

@@ -1,18 +0,0 @@
-from _typeshed import FileDescriptorOrPath
-from collections.abc import Sized
-
-__all__ = ["ensure_running", "register", "unregister"]
-
-class ResourceTracker:
-    def getfd(self) -> int | None: ...
-    def ensure_running(self) -> None: ...
-    def register(self, name: Sized, rtype: str) -> None: ...
-    def unregister(self, name: Sized, rtype: str) -> None: ...
-
-_resource_tracker: ResourceTracker
-ensure_running = _resource_tracker.ensure_running
-register = _resource_tracker.register
-unregister = _resource_tracker.unregister
-getfd = _resource_tracker.getfd
-
-def main(fd: FileDescriptorOrPath) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi

@@ -1,40 +0,0 @@
-import sys
-from collections.abc import Iterable
-from typing import Any, Generic, TypeVar, overload
-from typing_extensions import Self
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["SharedMemory", "ShareableList"]
-
-_SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
-
-class SharedMemory:
-    def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
-    @property
-    def buf(self) -> memoryview: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def size(self) -> int: ...
-    def close(self) -> None: ...
-    def unlink(self) -> None: ...
-    def __del__(self) -> None: ...
-
-class ShareableList(Generic[_SLT]):
-    shm: SharedMemory
-    @overload
-    def __init__(self, sequence: None = None, *, name: str | None = None) -> None: ...
-    @overload
-    def __init__(self, sequence: Iterable[_SLT], *, name: str | None = None) -> None: ...
-    def __getitem__(self, position: int) -> _SLT: ...
-    def __setitem__(self, position: int, value: _SLT) -> None: ...
-    def __reduce__(self) -> tuple[Self, tuple[_SLT, ...]]: ...
-    def __len__(self) -> int: ...
-    @property
-    def format(self) -> str: ...
-    def count(self, value: _SLT) -> int: ...
-    def index(self, value: _SLT) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi

@@ -1,107 +0,0 @@
-import ctypes
-from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData, _SimpleCData, c_char
-from multiprocessing.context import BaseContext
-from multiprocessing.synchronize import _LockLike
-from types import TracebackType
-from typing import Any, Generic, Literal, Protocol, TypeVar, overload
-
-__all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
-
-_T = TypeVar("_T")
-_CT = TypeVar("_CT", bound=_CData)
-
-@overload
-def RawValue(typecode_or_type: type[_CT], *args: Any) -> _CT: ...
-@overload
-def RawValue(typecode_or_type: str, *args: Any) -> Any: ...
-@overload
-def RawArray(typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any]) -> ctypes.Array[_CT]: ...
-@overload
-def RawArray(typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
-@overload
-def Value(typecode_or_type: type[_CT], *args: Any, lock: Literal[False], ctx: BaseContext | None = None) -> _CT: ...
-@overload
-def Value(
-    typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
-) -> SynchronizedBase[_CT]: ...
-@overload
-def Value(
-    typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
-) -> SynchronizedBase[Any]: ...
-@overload
-def Value(
-    typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True, ctx: BaseContext | None = None
-) -> Any: ...
-@overload
-def Array(
-    typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False], ctx: BaseContext | None = None
-) -> _CT: ...
-@overload
-def Array(
-    typecode_or_type: type[_CT],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
-@overload
-def Array(
-    typecode_or_type: str,
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedArray[Any]: ...
-@overload
-def Array(
-    typecode_or_type: str | type[_CData],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: bool | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> Any: ...
-def copy(obj: _CT) -> _CT: ...
-@overload
-def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
-@overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
-@overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
-@overload
-def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
-
-class _AcquireFunc(Protocol):
-    def __call__(self, block: bool = ..., timeout: float | None = ..., /) -> bool: ...
-
-class SynchronizedBase(Generic[_CT]):
-    acquire: _AcquireFunc
-    release: Callable[[], None]
-    def __init__(self, obj: Any, lock: _LockLike | None = None, ctx: Any | None = None) -> None: ...
-    def __reduce__(self) -> tuple[Callable[[Any, _LockLike], SynchronizedBase[Any]], tuple[Any, _LockLike]]: ...
-    def get_obj(self) -> _CT: ...
-    def get_lock(self) -> _LockLike: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
-    value: _T
-
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
-    def __len__(self) -> int: ...
-    @overload
-    def __getitem__(self, i: slice) -> list[_CT]: ...
-    @overload
-    def __getitem__(self, i: int) -> _CT: ...
-    @overload
-    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
-    @overload
-    def __setitem__(self, i: int, value: _CT) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
-
-class SynchronizedString(SynchronizedArray[c_char]):
-    value: bytes
-    raw: bytes

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/spawn.pyi

@@ -1,32 +0,0 @@
-from collections.abc import Mapping, Sequence
-from types import ModuleType
-from typing import Any
-
-__all__ = [
-    "_main",
-    "freeze_support",
-    "set_executable",
-    "get_executable",
-    "get_preparation_data",
-    "get_command_line",
-    "import_main_path",
-]
-
-WINEXE: bool
-WINSERVICE: bool
-
-def set_executable(exe: str) -> None: ...
-def get_executable() -> str: ...
-def is_forking(argv: Sequence[str]) -> bool: ...
-def freeze_support() -> None: ...
-def get_command_line(**kwds: Any) -> list[str]: ...
-def spawn_main(pipe_handle: int, parent_pid: int | None = None, tracker_fd: int | None = None) -> None: ...
-
-# undocumented
-def _main(fd: int) -> Any: ...
-def get_preparation_data(name: str) -> dict[str, Any]: ...
-
-old_main_modules: list[ModuleType]
-
-def prepare(data: Mapping[str, Any]) -> None: ...
-def import_main_path(main_path: str) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/synchronize.pyi

@@ -1,54 +0,0 @@
-import threading
-from collections.abc import Callable
-from contextlib import AbstractContextManager
-from multiprocessing.context import BaseContext
-from types import TracebackType
-from typing_extensions import TypeAlias
-
-__all__ = ["Lock", "RLock", "Semaphore", "BoundedSemaphore", "Condition", "Event"]
-
-_LockLike: TypeAlias = Lock | RLock
-
-class Barrier(threading.Barrier):
-    def __init__(
-        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *ctx: BaseContext
-    ) -> None: ...
-
-class Condition(AbstractContextManager[bool]):
-    def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
-    def notify(self, n: int = 1) -> None: ...
-    def notify_all(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-    def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Event:
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-    def is_set(self) -> bool: ...
-    def set(self) -> None: ...
-    def clear(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-
-# Not part of public API
-class SemLock(AbstractContextManager[bool]):
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Lock(SemLock):
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-
-class RLock(SemLock):
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-
-class Semaphore(SemLock):
-    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
-
-class BoundedSemaphore(Semaphore):
-    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/util.pyi

@@ -1,98 +0,0 @@
-import threading
-from _typeshed import ConvertibleToInt, Incomplete, Unused
-from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
-from logging import Logger, _Level as _LoggingLevel
-from typing import Any, Generic, TypeVar, overload
-
-__all__ = [
-    "sub_debug",
-    "debug",
-    "info",
-    "sub_warning",
-    "get_logger",
-    "log_to_stderr",
-    "get_temp_dir",
-    "register_after_fork",
-    "is_exiting",
-    "Finalize",
-    "ForkAwareThreadLock",
-    "ForkAwareLocal",
-    "close_all_fds_except",
-    "SUBDEBUG",
-    "SUBWARNING",
-]
-
-_T = TypeVar("_T")
-_R_co = TypeVar("_R_co", default=Any, covariant=True)
-
-NOTSET: int
-SUBDEBUG: int
-DEBUG: int
-INFO: int
-SUBWARNING: int
-
-LOGGER_NAME: str
-DEFAULT_LOGGING_FORMAT: str
-
-def sub_debug(msg: object, *args: object) -> None: ...
-def debug(msg: object, *args: object) -> None: ...
-def info(msg: object, *args: object) -> None: ...
-def sub_warning(msg: object, *args: object) -> None: ...
-def get_logger() -> Logger: ...
-def log_to_stderr(level: _LoggingLevel | None = None) -> Logger: ...
-def is_abstract_socket_namespace(address: str | bytes | None) -> bool: ...
-
-abstract_sockets_supported: bool
-
-def get_temp_dir() -> str: ...
-def register_after_fork(obj: _T, func: Callable[[_T], object]) -> None: ...
-
-class Finalize(Generic[_R_co]):
-    # "args" and "kwargs" are passed as arguments to "callback".
-    @overload
-    def __init__(
-        self,
-        obj: None,
-        callback: Callable[..., _R_co],
-        *,
-        args: Sequence[Any] = (),
-        kwargs: Mapping[str, Any] | None = None,
-        exitpriority: int,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self, obj: None, callback: Callable[..., _R_co], args: Sequence[Any], kwargs: Mapping[str, Any] | None, exitpriority: int
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        obj: Any,
-        callback: Callable[..., _R_co],
-        args: Sequence[Any] = (),
-        kwargs: Mapping[str, Any] | None = None,
-        exitpriority: int | None = None,
-    ) -> None: ...
-    def __call__(
-        self,
-        wr: Unused = None,
-        _finalizer_registry: MutableMapping[Incomplete, Incomplete] = {},
-        sub_debug: Callable[..., object] = ...,
-        getpid: Callable[[], int] = ...,
-    ) -> _R_co: ...
-    def cancel(self) -> None: ...
-    def still_active(self) -> bool: ...
-
-def is_exiting() -> bool: ...
-
-class ForkAwareThreadLock:
-    acquire: Callable[[bool, float], bool]
-    release: Callable[[], None]
-    def __enter__(self) -> bool: ...
-    def __exit__(self, *args: Unused) -> None: ...
-
-class ForkAwareLocal(threading.local): ...
-
-MAXFD: int
-
-def close_all_fds_except(fds: Iterable[int]) -> None: ...
-def spawnv_passfds(path: bytes, args: Sequence[ConvertibleToInt], passfds: Sequence[int]) -> int: ...

jaclang/vendor/mypy/typeshed/stdlib/netrc.pyi

@@ -1,23 +0,0 @@
-import sys
-from _typeshed import StrOrBytesPath
-from typing_extensions import TypeAlias
-
-__all__ = ["netrc", "NetrcParseError"]
-
-class NetrcParseError(Exception):
-    filename: str | None
-    lineno: int | None
-    msg: str
-    def __init__(self, msg: str, filename: StrOrBytesPath | None = None, lineno: int | None = None) -> None: ...
-
-# (login, account, password) tuple
-if sys.version_info >= (3, 11):
-    _NetrcTuple: TypeAlias = tuple[str, str, str]
-else:
-    _NetrcTuple: TypeAlias = tuple[str, str | None, str | None]
-
-class netrc:
-    hosts: dict[str, _NetrcTuple]
-    macros: dict[str, list[str]]
-    def __init__(self, file: StrOrBytesPath | None = None) -> None: ...
-    def authenticators(self, host: str) -> _NetrcTuple | None: ...

jaclang/vendor/mypy/typeshed/stdlib/nis.pyi

@@ -1,9 +0,0 @@
-import sys
-
-if sys.platform != "win32":
-    def cat(map: str, domain: str = ...) -> dict[str, str]: ...
-    def get_default_domain() -> str: ...
-    def maps(domain: str = ...) -> list[str]: ...
-    def match(key: str, map: str, domain: str = ...) -> str: ...
-
-    class error(Exception): ...

jaclang/vendor/mypy/typeshed/stdlib/nntplib.pyi

@@ -1,125 +0,0 @@
-import datetime
-import socket
-import ssl
-import sys
-from _typeshed import Unused
-from builtins import list as _list  # conflicts with a method named "list"
-from collections.abc import Iterable
-from typing import IO, Any, Literal, NamedTuple
-from typing_extensions import Self, TypeAlias
-
-__all__ = [
-    "NNTP",
-    "NNTPError",
-    "NNTPReplyError",
-    "NNTPTemporaryError",
-    "NNTPPermanentError",
-    "NNTPProtocolError",
-    "NNTPDataError",
-    "decode_header",
-    "NNTP_SSL",
-]
-
-_File: TypeAlias = IO[bytes] | bytes | str | None
-
-class NNTPError(Exception):
-    response: str
-
-class NNTPReplyError(NNTPError): ...
-class NNTPTemporaryError(NNTPError): ...
-class NNTPPermanentError(NNTPError): ...
-class NNTPProtocolError(NNTPError): ...
-class NNTPDataError(NNTPError): ...
-
-NNTP_PORT: Literal[119]
-NNTP_SSL_PORT: Literal[563]
-
-class GroupInfo(NamedTuple):
-    group: str
-    last: str
-    first: str
-    flag: str
-
-class ArticleInfo(NamedTuple):
-    number: int
-    message_id: str
-    lines: list[bytes]
-
-def decode_header(header_str: str) -> str: ...
-
-class NNTP:
-    encoding: str
-    errors: str
-
-    host: str
-    port: int
-    sock: socket.socket
-    file: IO[bytes]
-    debugging: int
-    welcome: str
-    readermode_afterauth: bool
-    tls_on: bool
-    authenticated: bool
-    nntp_implementation: str
-    nntp_version: int
-    def __init__(
-        self,
-        host: str,
-        port: int = 119,
-        user: str | None = None,
-        password: str | None = None,
-        readermode: bool | None = None,
-        usenetrc: bool = False,
-        timeout: float = ...,
-    ) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, *args: Unused) -> None: ...
-    def getwelcome(self) -> str: ...
-    def getcapabilities(self) -> dict[str, _list[str]]: ...
-    def set_debuglevel(self, level: int) -> None: ...
-    def debug(self, level: int) -> None: ...
-    def capabilities(self) -> tuple[str, dict[str, _list[str]]]: ...
-    def newgroups(self, date: datetime.date | datetime.datetime, *, file: _File = None) -> tuple[str, _list[str]]: ...
-    def newnews(self, group: str, date: datetime.date | datetime.datetime, *, file: _File = None) -> tuple[str, _list[str]]: ...
-    def list(self, group_pattern: str | None = None, *, file: _File = None) -> tuple[str, _list[str]]: ...
-    def description(self, group: str) -> str: ...
-    def descriptions(self, group_pattern: str) -> tuple[str, dict[str, str]]: ...
-    def group(self, name: str) -> tuple[str, int, int, int, str]: ...
-    def help(self, *, file: _File = None) -> tuple[str, _list[str]]: ...
-    def stat(self, message_spec: Any = None) -> tuple[str, int, str]: ...
-    def next(self) -> tuple[str, int, str]: ...
-    def last(self) -> tuple[str, int, str]: ...
-    def head(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
-    def body(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
-    def article(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
-    def slave(self) -> str: ...
-    def xhdr(self, hdr: str, str: Any, *, file: _File = None) -> tuple[str, _list[str]]: ...
-    def xover(self, start: int, end: int, *, file: _File = None) -> tuple[str, _list[tuple[int, dict[str, str]]]]: ...
-    def over(
-        self, message_spec: None | str | _list[Any] | tuple[Any, ...], *, file: _File = None
-    ) -> tuple[str, _list[tuple[int, dict[str, str]]]]: ...
-    if sys.version_info < (3, 9):
-        def xgtitle(self, group: str, *, file: _File = None) -> tuple[str, _list[tuple[str, str]]]: ...
-        def xpath(self, id: Any) -> tuple[str, str]: ...
-
-    def date(self) -> tuple[str, datetime.datetime]: ...
-    def post(self, data: bytes | Iterable[bytes]) -> str: ...
-    def ihave(self, message_id: Any, data: bytes | Iterable[bytes]) -> str: ...
-    def quit(self) -> str: ...
-    def login(self, user: str | None = None, password: str | None = None, usenetrc: bool = True) -> None: ...
-    def starttls(self, context: ssl.SSLContext | None = None) -> None: ...
-
-class NNTP_SSL(NNTP):
-    ssl_context: ssl.SSLContext | None
-    sock: ssl.SSLSocket
-    def __init__(
-        self,
-        host: str,
-        port: int = 563,
-        user: str | None = None,
-        password: str | None = None,
-        ssl_context: ssl.SSLContext | None = None,
-        readermode: bool | None = None,
-        usenetrc: bool = False,
-        timeout: float = ...,
-    ) -> None: ...