jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,400 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,13 @@
+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: ...