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

jaclang/vendor/mypy/typeshed/stdlib/urllib/parse.pyi

@@ -1,210 +0,0 @@
-import sys
-from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import Any, AnyStr, Generic, Literal, NamedTuple, TypeVar, overload
-from typing_extensions import TypeAlias
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = [
-    "urlparse",
-    "urlunparse",
-    "urljoin",
-    "urldefrag",
-    "urlsplit",
-    "urlunsplit",
-    "urlencode",
-    "parse_qs",
-    "parse_qsl",
-    "quote",
-    "quote_plus",
-    "quote_from_bytes",
-    "unquote",
-    "unquote_plus",
-    "unquote_to_bytes",
-    "DefragResult",
-    "ParseResult",
-    "SplitResult",
-    "DefragResultBytes",
-    "ParseResultBytes",
-    "SplitResultBytes",
-]
-
-uses_relative: list[str]
-uses_netloc: list[str]
-uses_params: list[str]
-non_hierarchical: list[str]
-uses_query: list[str]
-uses_fragment: list[str]
-scheme_chars: str
-if sys.version_info < (3, 11):
-    MAX_CACHE_SIZE: int
-
-class _ResultMixinStr:
-    def encode(self, encoding: str = "ascii", errors: str = "strict") -> _ResultMixinBytes: ...
-
-class _ResultMixinBytes:
-    def decode(self, encoding: str = "ascii", errors: str = "strict") -> _ResultMixinStr: ...
-
-class _NetlocResultMixinBase(Generic[AnyStr]):
-    @property
-    def username(self) -> AnyStr | None: ...
-    @property
-    def password(self) -> AnyStr | None: ...
-    @property
-    def hostname(self) -> AnyStr | None: ...
-    @property
-    def port(self) -> int | None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ...
-class _NetlocResultMixinBytes(_NetlocResultMixinBase[bytes], _ResultMixinBytes): ...
-
-class _DefragResultBase(NamedTuple, Generic[AnyStr]):
-    url: AnyStr
-    fragment: AnyStr
-
-class _SplitResultBase(NamedTuple, Generic[AnyStr]):
-    scheme: AnyStr
-    netloc: AnyStr
-    path: AnyStr
-    query: AnyStr
-    fragment: AnyStr
-
-class _ParseResultBase(NamedTuple, Generic[AnyStr]):
-    scheme: AnyStr
-    netloc: AnyStr
-    path: AnyStr
-    params: AnyStr
-    query: AnyStr
-    fragment: AnyStr
-
-# Structured result objects for string data
-class DefragResult(_DefragResultBase[str], _ResultMixinStr):
-    def geturl(self) -> str: ...
-
-class SplitResult(_SplitResultBase[str], _NetlocResultMixinStr):
-    def geturl(self) -> str: ...
-
-class ParseResult(_ParseResultBase[str], _NetlocResultMixinStr):
-    def geturl(self) -> str: ...
-
-# Structured result objects for bytes data
-class DefragResultBytes(_DefragResultBase[bytes], _ResultMixinBytes):
-    def geturl(self) -> bytes: ...
-
-class SplitResultBytes(_SplitResultBase[bytes], _NetlocResultMixinBytes):
-    def geturl(self) -> bytes: ...
-
-class ParseResultBytes(_ParseResultBase[bytes], _NetlocResultMixinBytes):
-    def geturl(self) -> bytes: ...
-
-def parse_qs(
-    qs: AnyStr | None,
-    keep_blank_values: bool = False,
-    strict_parsing: bool = False,
-    encoding: str = "utf-8",
-    errors: str = "replace",
-    max_num_fields: int | None = None,
-    separator: str = "&",
-) -> dict[AnyStr, list[AnyStr]]: ...
-def parse_qsl(
-    qs: AnyStr | None,
-    keep_blank_values: bool = False,
-    strict_parsing: bool = False,
-    encoding: str = "utf-8",
-    errors: str = "replace",
-    max_num_fields: int | None = None,
-    separator: str = "&",
-) -> list[tuple[AnyStr, AnyStr]]: ...
-@overload
-def quote(string: str, safe: str | Iterable[int] = "/", encoding: str | None = None, errors: str | None = None) -> str: ...
-@overload
-def quote(string: bytes | bytearray, safe: str | Iterable[int] = "/") -> str: ...
-def quote_from_bytes(bs: bytes | bytearray, safe: str | Iterable[int] = "/") -> str: ...
-@overload
-def quote_plus(string: str, safe: str | Iterable[int] = "", encoding: str | None = None, errors: str | None = None) -> str: ...
-@overload
-def quote_plus(string: bytes | bytearray, safe: str | Iterable[int] = "") -> str: ...
-
-if sys.version_info >= (3, 9):
-    def unquote(string: str | bytes, encoding: str = "utf-8", errors: str = "replace") -> str: ...
-
-else:
-    def unquote(string: str, encoding: str = "utf-8", errors: str = "replace") -> str: ...
-
-def unquote_to_bytes(string: str | bytes | bytearray) -> bytes: ...
-def unquote_plus(string: str, encoding: str = "utf-8", errors: str = "replace") -> str: ...
-@overload
-def urldefrag(url: str) -> DefragResult: ...
-@overload
-def urldefrag(url: bytes | bytearray | None) -> DefragResultBytes: ...
-
-_Q = TypeVar("_Q", bound=str | Iterable[int])
-_QueryType: TypeAlias = (
-    Mapping[Any, Any] | Mapping[Any, Sequence[Any]] | Sequence[tuple[Any, Any]] | Sequence[tuple[Any, Sequence[Any]]]
-)
-
-@overload
-def urlencode(
-    query: _QueryType,
-    doseq: bool = False,
-    safe: str = "",
-    encoding: str | None = None,
-    errors: str | None = None,
-    quote_via: Callable[[AnyStr, str, str, str], str] = ...,
-) -> str: ...
-@overload
-def urlencode(
-    query: _QueryType,
-    doseq: bool,
-    safe: _Q,
-    encoding: str | None = None,
-    errors: str | None = None,
-    quote_via: Callable[[AnyStr, _Q, str, str], str] = ...,
-) -> str: ...
-@overload
-def urlencode(
-    query: _QueryType,
-    doseq: bool = False,
-    *,
-    safe: _Q,
-    encoding: str | None = None,
-    errors: str | None = None,
-    quote_via: Callable[[AnyStr, _Q, str, str], str] = ...,
-) -> str: ...
-def urljoin(base: AnyStr, url: AnyStr | None, allow_fragments: bool = True) -> AnyStr: ...
-@overload
-def urlparse(url: str, scheme: str = "", allow_fragments: bool = True) -> ParseResult: ...
-@overload
-def urlparse(
-    url: bytes | bytearray | None, scheme: bytes | bytearray | None | Literal[""] = "", allow_fragments: bool = True
-) -> ParseResultBytes: ...
-@overload
-def urlsplit(url: str, scheme: str = "", allow_fragments: bool = True) -> SplitResult: ...
-
-if sys.version_info >= (3, 11):
-    @overload
-    def urlsplit(
-        url: bytes | None, scheme: bytes | None | Literal[""] = "", allow_fragments: bool = True
-    ) -> SplitResultBytes: ...
-
-else:
-    @overload
-    def urlsplit(
-        url: bytes | bytearray | None, scheme: bytes | bytearray | None | Literal[""] = "", allow_fragments: bool = True
-    ) -> SplitResultBytes: ...
-
-# Requires an iterable of length 6
-@overload
-def urlunparse(components: Iterable[None]) -> Literal[b""]: ...
-@overload
-def urlunparse(components: Iterable[AnyStr | None]) -> AnyStr: ...
-
-# Requires an iterable of length 5
-@overload
-def urlunsplit(components: Iterable[None]) -> Literal[b""]: ...
-@overload
-def urlunsplit(components: Iterable[AnyStr | None]) -> AnyStr: ...
-def unwrap(url: str) -> str: ...

jaclang/vendor/mypy/typeshed/stdlib/urllib/request.pyi

@@ -1,400 +0,0 @@
-import ssl
-import sys
-from _typeshed import ReadableBuffer, StrOrBytesPath, SupportsRead
-from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
-from email.message import Message
-from http.client import HTTPConnection, HTTPMessage, HTTPResponse
-from http.cookiejar import CookieJar
-from re import Pattern
-from typing import IO, Any, ClassVar, NoReturn, Protocol, TypeVar, overload
-from typing_extensions import TypeAlias
-from urllib.error import HTTPError as HTTPError
-from urllib.response import addclosehook, addinfourl
-
-__all__ = [
-    "Request",
-    "OpenerDirector",
-    "BaseHandler",
-    "HTTPDefaultErrorHandler",
-    "HTTPRedirectHandler",
-    "HTTPCookieProcessor",
-    "ProxyHandler",
-    "HTTPPasswordMgr",
-    "HTTPPasswordMgrWithDefaultRealm",
-    "HTTPPasswordMgrWithPriorAuth",
-    "AbstractBasicAuthHandler",
-    "HTTPBasicAuthHandler",
-    "ProxyBasicAuthHandler",
-    "AbstractDigestAuthHandler",
-    "HTTPDigestAuthHandler",
-    "ProxyDigestAuthHandler",
-    "HTTPHandler",
-    "FileHandler",
-    "FTPHandler",
-    "CacheFTPHandler",
-    "DataHandler",
-    "UnknownHandler",
-    "HTTPErrorProcessor",
-    "urlopen",
-    "install_opener",
-    "build_opener",
-    "pathname2url",
-    "url2pathname",
-    "getproxies",
-    "urlretrieve",
-    "urlcleanup",
-    "URLopener",
-    "FancyURLopener",
-    "HTTPSHandler",
-]
-
-_T = TypeVar("_T")
-_UrlopenRet: TypeAlias = Any
-_DataType: TypeAlias = ReadableBuffer | SupportsRead[bytes] | Iterable[bytes] | None
-
-def urlopen(
-    url: str | Request,
-    data: _DataType | None = None,
-    timeout: float | None = ...,
-    *,
-    cafile: str | None = None,
-    capath: str | None = None,
-    cadefault: bool = False,
-    context: ssl.SSLContext | None = None,
-) -> _UrlopenRet: ...
-def install_opener(opener: OpenerDirector) -> None: ...
-def build_opener(*handlers: BaseHandler | Callable[[], BaseHandler]) -> OpenerDirector: ...
-
-if sys.platform == "win32":
-    from nturl2path import pathname2url as pathname2url, url2pathname as url2pathname
-else:
-    def url2pathname(pathname: str) -> str: ...
-    def pathname2url(pathname: str) -> str: ...
-
-def getproxies() -> dict[str, str]: ...
-def parse_http_list(s: str) -> list[str]: ...
-def parse_keqv_list(l: list[str]) -> dict[str, str]: ...
-
-if sys.platform == "win32" or sys.platform == "darwin":
-    def proxy_bypass(host: str) -> Any: ...  # undocumented
-
-else:
-    def proxy_bypass(host: str, proxies: Mapping[str, str] | None = None) -> Any: ...  # undocumented
-
-class Request:
-    @property
-    def full_url(self) -> str: ...
-    @full_url.setter
-    def full_url(self, value: str) -> None: ...
-    @full_url.deleter
-    def full_url(self) -> None: ...
-    type: str
-    host: str
-    origin_req_host: str
-    selector: str
-    data: _DataType
-    headers: MutableMapping[str, str]
-    unredirected_hdrs: dict[str, str]
-    unverifiable: bool
-    method: str | None
-    timeout: float | None  # Undocumented, only set after __init__() by OpenerDirector.open()
-    def __init__(
-        self,
-        url: str,
-        data: _DataType = None,
-        headers: MutableMapping[str, str] = {},
-        origin_req_host: str | None = None,
-        unverifiable: bool = False,
-        method: str | None = None,
-    ) -> None: ...
-    def get_method(self) -> str: ...
-    def add_header(self, key: str, val: str) -> None: ...
-    def add_unredirected_header(self, key: str, val: str) -> None: ...
-    def has_header(self, header_name: str) -> bool: ...
-    def remove_header(self, header_name: str) -> None: ...
-    def get_full_url(self) -> str: ...
-    def set_proxy(self, host: str, type: str) -> None: ...
-    @overload
-    def get_header(self, header_name: str) -> str | None: ...
-    @overload
-    def get_header(self, header_name: str, default: _T) -> str | _T: ...
-    def header_items(self) -> list[tuple[str, str]]: ...
-    def has_proxy(self) -> bool: ...
-
-class OpenerDirector:
-    addheaders: list[tuple[str, str]]
-    def add_handler(self, handler: BaseHandler) -> None: ...
-    def open(self, fullurl: str | Request, data: _DataType = None, timeout: float | None = ...) -> _UrlopenRet: ...
-    def error(self, proto: str, *args: Any) -> _UrlopenRet: ...
-    def close(self) -> None: ...
-
-class BaseHandler:
-    handler_order: ClassVar[int]
-    parent: OpenerDirector
-    def add_parent(self, parent: OpenerDirector) -> None: ...
-    def close(self) -> None: ...
-    def __lt__(self, other: object) -> bool: ...
-
-class HTTPDefaultErrorHandler(BaseHandler):
-    def http_error_default(
-        self, req: Request, fp: IO[bytes], code: int, msg: str, hdrs: HTTPMessage
-    ) -> HTTPError: ...  # undocumented
-
-class HTTPRedirectHandler(BaseHandler):
-    max_redirections: ClassVar[int]  # undocumented
-    max_repeats: ClassVar[int]  # undocumented
-    inf_msg: ClassVar[str]  # undocumented
-    def redirect_request(
-        self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage, newurl: str
-    ) -> Request | None: ...
-    def http_error_301(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-    def http_error_302(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-    def http_error_303(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-    def http_error_307(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-    if sys.version_info >= (3, 11):
-        def http_error_308(
-            self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage
-        ) -> _UrlopenRet | None: ...
-
-class HTTPCookieProcessor(BaseHandler):
-    cookiejar: CookieJar
-    def __init__(self, cookiejar: CookieJar | None = None) -> None: ...
-    def http_request(self, request: Request) -> Request: ...  # undocumented
-    def http_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
-    def https_request(self, request: Request) -> Request: ...  # undocumented
-    def https_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
-
-class ProxyHandler(BaseHandler):
-    def __init__(self, proxies: dict[str, str] | None = None) -> None: ...
-    def proxy_open(self, req: Request, proxy: str, type: str) -> _UrlopenRet | None: ...  # undocumented
-    # TODO add a method for every (common) proxy protocol
-
-class HTTPPasswordMgr:
-    def add_password(self, realm: str, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
-    def find_user_password(self, realm: str, authuri: str) -> tuple[str | None, str | None]: ...
-    def is_suburi(self, base: str, test: str) -> bool: ...  # undocumented
-    def reduce_uri(self, uri: str, default_port: bool = True) -> tuple[str, str]: ...  # undocumented
-
-class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
-    def add_password(self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
-    def find_user_password(self, realm: str | None, authuri: str) -> tuple[str | None, str | None]: ...
-
-class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
-    def add_password(
-        self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str, is_authenticated: bool = False
-    ) -> None: ...
-    def update_authenticated(self, uri: str | Sequence[str], is_authenticated: bool = False) -> None: ...
-    def is_authenticated(self, authuri: str) -> bool | None: ...
-
-class AbstractBasicAuthHandler:
-    rx: ClassVar[Pattern[str]]  # undocumented
-    passwd: HTTPPasswordMgr
-    add_password: Callable[[str, str | Sequence[str], str, str], None]
-    def __init__(self, password_mgr: HTTPPasswordMgr | None = None) -> None: ...
-    def http_error_auth_reqed(self, authreq: str, host: str, req: Request, headers: HTTPMessage) -> None: ...
-    def http_request(self, req: Request) -> Request: ...  # undocumented
-    def http_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
-    def https_request(self, req: Request) -> Request: ...  # undocumented
-    def https_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
-    def retry_http_basic_auth(self, host: str, req: Request, realm: str) -> _UrlopenRet | None: ...  # undocumented
-
-class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
-    auth_header: ClassVar[str]  # undocumented
-    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-
-class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
-    auth_header: ClassVar[str]
-    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-
-class AbstractDigestAuthHandler:
-    def __init__(self, passwd: HTTPPasswordMgr | None = None) -> None: ...
-    def reset_retry_count(self) -> None: ...
-    def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: HTTPMessage) -> None: ...
-    def retry_http_digest_auth(self, req: Request, auth: str) -> _UrlopenRet | None: ...
-    def get_cnonce(self, nonce: str) -> str: ...
-    def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str | None: ...
-    def get_algorithm_impls(self, algorithm: str) -> tuple[Callable[[str], str], Callable[[str, str], str]]: ...
-    def get_entity_digest(self, data: ReadableBuffer | None, chal: Mapping[str, str]) -> str | None: ...
-
-class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
-    auth_header: ClassVar[str]  # undocumented
-    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-
-class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
-    auth_header: ClassVar[str]  # undocumented
-    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
-
-class _HTTPConnectionProtocol(Protocol):
-    def __call__(
-        self,
-        host: str,
-        /,
-        *,
-        port: int | None = ...,
-        timeout: float = ...,
-        source_address: tuple[str, int] | None = ...,
-        blocksize: int = ...,
-    ) -> HTTPConnection: ...
-
-class AbstractHTTPHandler(BaseHandler):  # undocumented
-    if sys.version_info >= (3, 12):
-        def __init__(self, debuglevel: int | None = None) -> None: ...
-    else:
-        def __init__(self, debuglevel: int = 0) -> None: ...
-
-    def set_http_debuglevel(self, level: int) -> None: ...
-    def do_request_(self, request: Request) -> Request: ...
-    def do_open(self, http_class: _HTTPConnectionProtocol, req: Request, **http_conn_args: Any) -> HTTPResponse: ...
-
-class HTTPHandler(AbstractHTTPHandler):
-    def http_open(self, req: Request) -> HTTPResponse: ...
-    def http_request(self, request: Request) -> Request: ...  # undocumented
-
-class HTTPSHandler(AbstractHTTPHandler):
-    if sys.version_info >= (3, 12):
-        def __init__(
-            self, debuglevel: int | None = None, context: ssl.SSLContext | None = None, check_hostname: bool | None = None
-        ) -> None: ...
-    else:
-        def __init__(
-            self, debuglevel: int = 0, context: ssl.SSLContext | None = None, check_hostname: bool | None = None
-        ) -> None: ...
-
-    def https_open(self, req: Request) -> HTTPResponse: ...
-    def https_request(self, request: Request) -> Request: ...  # undocumented
-
-class FileHandler(BaseHandler):
-    names: ClassVar[tuple[str, ...] | None]  # undocumented
-    def file_open(self, req: Request) -> addinfourl: ...
-    def get_names(self) -> tuple[str, ...]: ...  # undocumented
-    def open_local_file(self, req: Request) -> addinfourl: ...  # undocumented
-
-class DataHandler(BaseHandler):
-    def data_open(self, req: Request) -> addinfourl: ...
-
-class ftpwrapper:  # undocumented
-    def __init__(
-        self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: float | None = None, persistent: bool = True
-    ) -> None: ...
-    def close(self) -> None: ...
-    def endtransfer(self) -> None: ...
-    def file_close(self) -> None: ...
-    def init(self) -> None: ...
-    def real_close(self) -> None: ...
-    def retrfile(self, file: str, type: str) -> tuple[addclosehook, int | None]: ...
-
-class FTPHandler(BaseHandler):
-    def ftp_open(self, req: Request) -> addinfourl: ...
-    def connect_ftp(
-        self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: float
-    ) -> ftpwrapper: ...  # undocumented
-
-class CacheFTPHandler(FTPHandler):
-    def setTimeout(self, t: float) -> None: ...
-    def setMaxConns(self, m: int) -> None: ...
-    def check_cache(self) -> None: ...  # undocumented
-    def clear_cache(self) -> None: ...  # undocumented
-
-class UnknownHandler(BaseHandler):
-    def unknown_open(self, req: Request) -> NoReturn: ...
-
-class HTTPErrorProcessor(BaseHandler):
-    def http_response(self, request: Request, response: HTTPResponse) -> _UrlopenRet: ...
-    def https_response(self, request: Request, response: HTTPResponse) -> _UrlopenRet: ...
-
-def urlretrieve(
-    url: str,
-    filename: StrOrBytesPath | None = None,
-    reporthook: Callable[[int, int, int], object] | None = None,
-    data: _DataType = None,
-) -> tuple[str, HTTPMessage]: ...
-def urlcleanup() -> None: ...
-
-class URLopener:
-    version: ClassVar[str]
-    def __init__(self, proxies: dict[str, str] | None = None, **x509: str) -> None: ...
-    def open(self, fullurl: str, data: ReadableBuffer | None = None) -> _UrlopenRet: ...
-    def open_unknown(self, fullurl: str, data: ReadableBuffer | None = None) -> _UrlopenRet: ...
-    def retrieve(
-        self,
-        url: str,
-        filename: str | None = None,
-        reporthook: Callable[[int, int, int], object] | None = None,
-        data: ReadableBuffer | None = None,
-    ) -> tuple[str, Message | None]: ...
-    def addheader(self, *args: tuple[str, str]) -> None: ...  # undocumented
-    def cleanup(self) -> None: ...  # undocumented
-    def close(self) -> None: ...  # undocumented
-    def http_error(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = None
-    ) -> _UrlopenRet: ...  # undocumented
-    def http_error_default(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage
-    ) -> _UrlopenRet: ...  # undocumented
-    def open_data(self, url: str, data: ReadableBuffer | None = None) -> addinfourl: ...  # undocumented
-    def open_file(self, url: str) -> addinfourl: ...  # undocumented
-    def open_ftp(self, url: str) -> addinfourl: ...  # undocumented
-    def open_http(self, url: str, data: ReadableBuffer | None = None) -> _UrlopenRet: ...  # undocumented
-    def open_https(self, url: str, data: ReadableBuffer | None = None) -> _UrlopenRet: ...  # undocumented
-    def open_local_file(self, url: str) -> addinfourl: ...  # undocumented
-    def open_unknown_proxy(self, proxy: str, fullurl: str, data: ReadableBuffer | None = None) -> None: ...  # undocumented
-    def __del__(self) -> None: ...
-
-class FancyURLopener(URLopener):
-    def prompt_user_passwd(self, host: str, realm: str) -> tuple[str, str]: ...
-    def get_user_passwd(self, host: str, realm: str, clear_cache: int = 0) -> tuple[str, str]: ...  # undocumented
-    def http_error_301(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
-    def http_error_302(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
-    def http_error_303(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
-    def http_error_307(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
-    if sys.version_info >= (3, 11):
-        def http_error_308(
-            self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None = None
-        ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
-
-    def http_error_401(
-        self,
-        url: str,
-        fp: IO[bytes],
-        errcode: int,
-        errmsg: str,
-        headers: HTTPMessage,
-        data: ReadableBuffer | None = None,
-        retry: bool = False,
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def http_error_407(
-        self,
-        url: str,
-        fp: IO[bytes],
-        errcode: int,
-        errmsg: str,
-        headers: HTTPMessage,
-        data: ReadableBuffer | None = None,
-        retry: bool = False,
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def http_error_default(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage
-    ) -> addinfourl: ...  # undocumented
-    def redirect_internal(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: ReadableBuffer | None
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def retry_http_basic_auth(
-        self, url: str, realm: str, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def retry_https_basic_auth(
-        self, url: str, realm: str, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def retry_proxy_http_basic_auth(
-        self, url: str, realm: str, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | None: ...  # undocumented
-    def retry_proxy_https_basic_auth(
-        self, url: str, realm: str, data: ReadableBuffer | None = None
-    ) -> _UrlopenRet | None: ...  # undocumented

jaclang/vendor/mypy/typeshed/stdlib/urllib/response.pyi

@@ -1,43 +0,0 @@
-import sys
-import tempfile
-from _typeshed import ReadableBuffer
-from collections.abc import Callable, Iterable
-from email.message import Message
-from types import TracebackType
-from typing import IO, Any
-
-__all__ = ["addbase", "addclosehook", "addinfo", "addinfourl"]
-
-class addbase(tempfile._TemporaryFileWrapper[bytes]):
-    fp: IO[bytes]
-    def __init__(self, fp: IO[bytes]) -> None: ...
-    def __exit__(
-        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-    # These methods don't actually exist, but the class inherits at runtime from
-    # tempfile._TemporaryFileWrapper, which uses __getattr__ to delegate to the
-    # underlying file object. To satisfy the BinaryIO interface, we pretend that this
-    # class has these additional methods.
-    def write(self, s: ReadableBuffer) -> int: ...
-    def writelines(self, lines: Iterable[ReadableBuffer]) -> None: ...
-
-class addclosehook(addbase):
-    closehook: Callable[..., object]
-    hookargs: tuple[Any, ...]
-    def __init__(self, fp: IO[bytes], closehook: Callable[..., object], *hookargs: Any) -> None: ...
-
-class addinfo(addbase):
-    headers: Message
-    def __init__(self, fp: IO[bytes], headers: Message) -> None: ...
-    def info(self) -> Message: ...
-
-class addinfourl(addinfo):
-    url: str
-    code: int | None
-    if sys.version_info >= (3, 9):
-        @property
-        def status(self) -> int | None: ...
-
-    def __init__(self, fp: IO[bytes], headers: Message, url: str, code: int | None = None) -> None: ...
-    def geturl(self) -> str: ...
-    def getcode(self) -> int | None: ...

jaclang/vendor/mypy/typeshed/stdlib/urllib/robotparser.pyi

@@ -1,20 +0,0 @@
-from collections.abc import Iterable
-from typing import NamedTuple
-
-__all__ = ["RobotFileParser"]
-
-class RequestRate(NamedTuple):
-    requests: int
-    seconds: int
-
-class RobotFileParser:
-    def __init__(self, url: str = "") -> None: ...
-    def set_url(self, url: str) -> None: ...
-    def read(self) -> None: ...
-    def parse(self, lines: Iterable[str]) -> None: ...
-    def can_fetch(self, useragent: str, url: str) -> bool: ...
-    def mtime(self) -> int: ...
-    def modified(self) -> None: ...
-    def crawl_delay(self, useragent: str) -> str | None: ...
-    def request_rate(self, useragent: str) -> RequestRate | None: ...
-    def site_maps(self) -> list[str] | None: ...

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

@@ -1,13 +0,0 @@
-from typing import BinaryIO
-from typing_extensions import TypeAlias
-
-__all__ = ["Error", "encode", "decode"]
-
-_File: TypeAlias = str | BinaryIO
-
-class Error(Exception): ...
-
-def encode(
-    in_file: _File, out_file: _File, name: str | None = None, mode: int | None = None, *, backtick: bool = False
-) -> None: ...
-def decode(in_file: _File, out_file: _File | None = None, mode: int | None = None, quiet: bool = False) -> None: ...