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

jaclang/vendor/mypy/typeshed/stdlib/http/client.pyi

@@ -1,259 +0,0 @@
-import email.message
-import io
-import ssl
-import sys
-import types
-from _typeshed import ReadableBuffer, SupportsRead, WriteableBuffer
-from collections.abc import Callable, Iterable, Iterator, Mapping
-from socket import socket
-from typing import Any, BinaryIO, TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-__all__ = [
-    "HTTPResponse",
-    "HTTPConnection",
-    "HTTPException",
-    "NotConnected",
-    "UnknownProtocol",
-    "UnknownTransferEncoding",
-    "UnimplementedFileMode",
-    "IncompleteRead",
-    "InvalidURL",
-    "ImproperConnectionState",
-    "CannotSendRequest",
-    "CannotSendHeader",
-    "ResponseNotReady",
-    "BadStatusLine",
-    "LineTooLong",
-    "RemoteDisconnected",
-    "error",
-    "responses",
-    "HTTPSConnection",
-]
-
-_DataType: TypeAlias = SupportsRead[bytes] | Iterable[ReadableBuffer] | ReadableBuffer
-_T = TypeVar("_T")
-
-HTTP_PORT: int
-HTTPS_PORT: int
-
-CONTINUE: int
-SWITCHING_PROTOCOLS: int
-PROCESSING: int
-
-OK: int
-CREATED: int
-ACCEPTED: int
-NON_AUTHORITATIVE_INFORMATION: int
-NO_CONTENT: int
-RESET_CONTENT: int
-PARTIAL_CONTENT: int
-MULTI_STATUS: int
-IM_USED: int
-
-MULTIPLE_CHOICES: int
-MOVED_PERMANENTLY: int
-FOUND: int
-SEE_OTHER: int
-NOT_MODIFIED: int
-USE_PROXY: int
-TEMPORARY_REDIRECT: int
-
-BAD_REQUEST: int
-UNAUTHORIZED: int
-PAYMENT_REQUIRED: int
-FORBIDDEN: int
-NOT_FOUND: int
-METHOD_NOT_ALLOWED: int
-NOT_ACCEPTABLE: int
-PROXY_AUTHENTICATION_REQUIRED: int
-REQUEST_TIMEOUT: int
-CONFLICT: int
-GONE: int
-LENGTH_REQUIRED: int
-PRECONDITION_FAILED: int
-REQUEST_ENTITY_TOO_LARGE: int
-REQUEST_URI_TOO_LONG: int
-UNSUPPORTED_MEDIA_TYPE: int
-REQUESTED_RANGE_NOT_SATISFIABLE: int
-EXPECTATION_FAILED: int
-UNPROCESSABLE_ENTITY: int
-LOCKED: int
-FAILED_DEPENDENCY: int
-UPGRADE_REQUIRED: int
-PRECONDITION_REQUIRED: int
-TOO_MANY_REQUESTS: int
-REQUEST_HEADER_FIELDS_TOO_LARGE: int
-
-INTERNAL_SERVER_ERROR: int
-NOT_IMPLEMENTED: int
-BAD_GATEWAY: int
-SERVICE_UNAVAILABLE: int
-GATEWAY_TIMEOUT: int
-HTTP_VERSION_NOT_SUPPORTED: int
-INSUFFICIENT_STORAGE: int
-NOT_EXTENDED: int
-NETWORK_AUTHENTICATION_REQUIRED: int
-
-responses: dict[int, str]
-
-class HTTPMessage(email.message.Message):
-    def getallmatchingheaders(self, name: str) -> list[str]: ...  # undocumented
-    # override below all of Message's methods that use `_HeaderType` / `_HeaderTypeParam` with `str`
-    # `HTTPMessage` breaks the Liskov substitution principle by only intending for `str` headers
-    # This is easier than making `Message` generic
-    def __getitem__(self, name: str) -> str | None: ...
-    def __setitem__(self, name: str, val: str) -> None: ...  # type: ignore[override]
-    def values(self) -> list[str]: ...
-    def items(self) -> list[tuple[str, str]]: ...
-    @overload
-    def get(self, name: str, failobj: None = None) -> str | None: ...
-    @overload
-    def get(self, name: str, failobj: _T) -> str | _T: ...
-    @overload
-    def get_all(self, name: str, failobj: None = None) -> list[str] | None: ...
-    @overload
-    def get_all(self, name: str, failobj: _T) -> list[str] | _T: ...
-    def replace_header(self, _name: str, _value: str) -> None: ...  # type: ignore[override]
-    def set_raw(self, name: str, value: str) -> None: ...  # type: ignore[override]
-    def raw_items(self) -> Iterator[tuple[str, str]]: ...
-
-def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ...
-
-class HTTPResponse(io.BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible method definitions in the base classes
-    msg: HTTPMessage
-    headers: HTTPMessage
-    version: int
-    debuglevel: int
-    fp: io.BufferedReader
-    closed: bool
-    status: int
-    reason: str
-    chunked: bool
-    chunk_left: int | None
-    length: int | None
-    will_close: bool
-    # url is set on instances of the class in urllib.request.AbstractHTTPHandler.do_open
-    # to match urllib.response.addinfourl's interface.
-    # It's not set in HTTPResponse.__init__ or any other method on the class
-    url: str
-    def __init__(self, sock: socket, debuglevel: int = 0, method: str | None = None, url: str | None = None) -> None: ...
-    def peek(self, n: int = -1) -> bytes: ...
-    def read(self, amt: int | None = None) -> bytes: ...
-    def read1(self, n: int = -1) -> bytes: ...
-    def readinto(self, b: WriteableBuffer) -> int: ...
-    def readline(self, limit: int = -1) -> bytes: ...  # type: ignore[override]
-    @overload
-    def getheader(self, name: str) -> str | None: ...
-    @overload
-    def getheader(self, name: str, default: _T) -> str | _T: ...
-    def getheaders(self) -> list[tuple[str, str]]: ...
-    def isclosed(self) -> bool: ...
-    def __iter__(self) -> Iterator[bytes]: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-    ) -> None: ...
-    def info(self) -> email.message.Message: ...
-    def geturl(self) -> str: ...
-    def getcode(self) -> int: ...
-    def begin(self) -> None: ...
-
-class HTTPConnection:
-    auto_open: int  # undocumented
-    debuglevel: int
-    default_port: int  # undocumented
-    response_class: type[HTTPResponse]  # undocumented
-    timeout: float | None
-    host: str
-    port: int
-    sock: socket | Any  # can be `None` if `.connect()` was not called
-    def __init__(
-        self,
-        host: str,
-        port: int | None = None,
-        timeout: float | None = ...,
-        source_address: tuple[str, int] | None = None,
-        blocksize: int = 8192,
-    ) -> None: ...
-    def request(
-        self,
-        method: str,
-        url: str,
-        body: _DataType | str | None = None,
-        headers: Mapping[str, str] = {},
-        *,
-        encode_chunked: bool = False,
-    ) -> None: ...
-    def getresponse(self) -> HTTPResponse: ...
-    def set_debuglevel(self, level: int) -> None: ...
-    if sys.version_info >= (3, 12):
-        def get_proxy_response_headers(self) -> HTTPMessage | None: ...
-
-    def set_tunnel(self, host: str, port: int | None = None, headers: Mapping[str, str] | None = None) -> None: ...
-    def connect(self) -> None: ...
-    def close(self) -> None: ...
-    def putrequest(self, method: str, url: str, skip_host: bool = False, skip_accept_encoding: bool = False) -> None: ...
-    def putheader(self, header: str | bytes, *argument: str | bytes) -> None: ...
-    def endheaders(self, message_body: _DataType | None = None, *, encode_chunked: bool = False) -> None: ...
-    def send(self, data: _DataType | str) -> None: ...
-
-class HTTPSConnection(HTTPConnection):
-    # Can be `None` if `.connect()` was not called:
-    sock: ssl.SSLSocket | Any
-    if sys.version_info >= (3, 12):
-        def __init__(
-            self,
-            host: str,
-            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,
-            host: str,
-            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: ...
-
-class HTTPException(Exception): ...
-
-error = HTTPException
-
-class NotConnected(HTTPException): ...
-class InvalidURL(HTTPException): ...
-
-class UnknownProtocol(HTTPException):
-    def __init__(self, version: str) -> None: ...
-
-class UnknownTransferEncoding(HTTPException): ...
-class UnimplementedFileMode(HTTPException): ...
-
-class IncompleteRead(HTTPException):
-    def __init__(self, partial: bytes, expected: int | None = None) -> None: ...
-    partial: bytes
-    expected: int | None
-
-class ImproperConnectionState(HTTPException): ...
-class CannotSendRequest(ImproperConnectionState): ...
-class CannotSendHeader(ImproperConnectionState): ...
-class ResponseNotReady(ImproperConnectionState): ...
-
-class BadStatusLine(HTTPException):
-    def __init__(self, line: str) -> None: ...
-
-class LineTooLong(HTTPException):
-    def __init__(self, line_type: str) -> None: ...
-
-class RemoteDisconnected(ConnectionResetError, BadStatusLine): ...

jaclang/vendor/mypy/typeshed/stdlib/http/cookiejar.pyi

@@ -1,159 +0,0 @@
-import sys
-from _typeshed import StrPath
-from collections.abc import Iterable, Iterator, Sequence
-from http.client import HTTPResponse
-from re import Pattern
-from typing import ClassVar, TypeVar, overload
-from urllib.request import Request
-
-__all__ = [
-    "Cookie",
-    "CookieJar",
-    "CookiePolicy",
-    "DefaultCookiePolicy",
-    "FileCookieJar",
-    "LWPCookieJar",
-    "LoadError",
-    "MozillaCookieJar",
-]
-
-_T = TypeVar("_T")
-
-class LoadError(OSError): ...
-
-class CookieJar(Iterable[Cookie]):
-    non_word_re: ClassVar[Pattern[str]]  # undocumented
-    quote_re: ClassVar[Pattern[str]]  # undocumented
-    strict_domain_re: ClassVar[Pattern[str]]  # undocumented
-    domain_re: ClassVar[Pattern[str]]  # undocumented
-    dots_re: ClassVar[Pattern[str]]  # undocumented
-    magic_re: ClassVar[Pattern[str]]  # undocumented
-    def __init__(self, policy: CookiePolicy | None = None) -> None: ...
-    def add_cookie_header(self, request: Request) -> None: ...
-    def extract_cookies(self, response: HTTPResponse, request: Request) -> None: ...
-    def set_policy(self, policy: CookiePolicy) -> None: ...
-    def make_cookies(self, response: HTTPResponse, request: Request) -> Sequence[Cookie]: ...
-    def set_cookie(self, cookie: Cookie) -> None: ...
-    def set_cookie_if_ok(self, cookie: Cookie, request: Request) -> None: ...
-    def clear(self, domain: str | None = None, path: str | None = None, name: str | None = None) -> None: ...
-    def clear_session_cookies(self) -> None: ...
-    def clear_expired_cookies(self) -> None: ...  # undocumented
-    def __iter__(self) -> Iterator[Cookie]: ...
-    def __len__(self) -> int: ...
-
-class FileCookieJar(CookieJar):
-    filename: str
-    delayload: bool
-    def __init__(self, filename: StrPath | None = None, delayload: bool = False, policy: CookiePolicy | None = None) -> None: ...
-    def save(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
-    def load(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
-    def revert(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
-
-class MozillaCookieJar(FileCookieJar):
-    if sys.version_info < (3, 10):
-        header: ClassVar[str]  # undocumented
-
-class LWPCookieJar(FileCookieJar):
-    def as_lwp_str(self, ignore_discard: bool = True, ignore_expires: bool = True) -> str: ...  # undocumented
-
-class CookiePolicy:
-    netscape: bool
-    rfc2965: bool
-    hide_cookie2: bool
-    def set_ok(self, cookie: Cookie, request: Request) -> bool: ...
-    def return_ok(self, cookie: Cookie, request: Request) -> bool: ...
-    def domain_return_ok(self, domain: str, request: Request) -> bool: ...
-    def path_return_ok(self, path: str, request: Request) -> bool: ...
-
-class DefaultCookiePolicy(CookiePolicy):
-    rfc2109_as_netscape: bool
-    strict_domain: bool
-    strict_rfc2965_unverifiable: bool
-    strict_ns_unverifiable: bool
-    strict_ns_domain: int
-    strict_ns_set_initial_dollar: bool
-    strict_ns_set_path: bool
-    DomainStrictNoDots: ClassVar[int]
-    DomainStrictNonDomain: ClassVar[int]
-    DomainRFC2965Match: ClassVar[int]
-    DomainLiberal: ClassVar[int]
-    DomainStrict: ClassVar[int]
-    def __init__(
-        self,
-        blocked_domains: Sequence[str] | None = None,
-        allowed_domains: Sequence[str] | None = None,
-        netscape: bool = True,
-        rfc2965: bool = False,
-        rfc2109_as_netscape: bool | None = None,
-        hide_cookie2: bool = False,
-        strict_domain: bool = False,
-        strict_rfc2965_unverifiable: bool = True,
-        strict_ns_unverifiable: bool = False,
-        strict_ns_domain: int = 0,
-        strict_ns_set_initial_dollar: bool = False,
-        strict_ns_set_path: bool = False,
-        secure_protocols: Sequence[str] = ("https", "wss"),
-    ) -> None: ...
-    def blocked_domains(self) -> tuple[str, ...]: ...
-    def set_blocked_domains(self, blocked_domains: Sequence[str]) -> None: ...
-    def is_blocked(self, domain: str) -> bool: ...
-    def allowed_domains(self) -> tuple[str, ...] | None: ...
-    def set_allowed_domains(self, allowed_domains: Sequence[str] | None) -> None: ...
-    def is_not_allowed(self, domain: str) -> bool: ...
-    def set_ok_version(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def set_ok_verifiability(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def set_ok_name(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def set_ok_path(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def set_ok_domain(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def set_ok_port(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_version(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_verifiability(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_secure(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_expires(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_port(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-    def return_ok_domain(self, cookie: Cookie, request: Request) -> bool: ...  # undocumented
-
-class Cookie:
-    version: int | None
-    name: str
-    value: str | None
-    port: str | None
-    path: str
-    path_specified: bool
-    secure: bool
-    expires: int | None
-    discard: bool
-    comment: str | None
-    comment_url: str | None
-    rfc2109: bool
-    port_specified: bool
-    domain: str  # undocumented
-    domain_specified: bool
-    domain_initial_dot: bool
-    def __init__(
-        self,
-        version: int | None,
-        name: str,
-        value: str | None,  # undocumented
-        port: str | None,
-        port_specified: bool,
-        domain: str,
-        domain_specified: bool,
-        domain_initial_dot: bool,
-        path: str,
-        path_specified: bool,
-        secure: bool,
-        expires: int | None,
-        discard: bool,
-        comment: str | None,
-        comment_url: str | None,
-        rest: dict[str, str],
-        rfc2109: bool = False,
-    ) -> None: ...
-    def has_nonstandard_attr(self, name: str) -> bool: ...
-    @overload
-    def get_nonstandard_attr(self, name: str) -> str | None: ...
-    @overload
-    def get_nonstandard_attr(self, name: str, default: _T) -> str | _T: ...
-    def set_nonstandard_attr(self, name: str, value: str) -> None: ...
-    def is_expired(self, now: int | None = None) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/http/cookies.pyi

@@ -1,60 +0,0 @@
-import sys
-from collections.abc import Iterable, Mapping
-from typing import Any, Generic, TypeVar, overload
-from typing_extensions import TypeAlias
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["CookieError", "BaseCookie", "SimpleCookie"]
-
-_DataType: TypeAlias = str | Mapping[str, str | Morsel[Any]]
-_T = TypeVar("_T")
-
-@overload
-def _quote(str: None) -> None: ...
-@overload
-def _quote(str: str) -> str: ...
-@overload
-def _unquote(str: None) -> None: ...
-@overload
-def _unquote(str: str) -> str: ...
-
-class CookieError(Exception): ...
-
-class Morsel(dict[str, Any], Generic[_T]):
-    @property
-    def value(self) -> str: ...
-    @property
-    def coded_value(self) -> _T: ...
-    @property
-    def key(self) -> str: ...
-    def __init__(self) -> None: ...
-    def set(self, key: str, val: str, coded_val: _T) -> None: ...
-    def setdefault(self, key: str, val: str | None = None) -> str: ...
-    # The dict update can also get a keywords argument so this is incompatible
-    @overload  # type: ignore[override]
-    def update(self, values: Mapping[str, str]) -> None: ...
-    @overload
-    def update(self, values: Iterable[tuple[str, str]]) -> None: ...
-    def isReservedKey(self, K: str) -> bool: ...
-    def output(self, attrs: list[str] | None = None, header: str = "Set-Cookie:") -> str: ...
-    __str__ = output
-    def js_output(self, attrs: list[str] | None = None) -> str: ...
-    def OutputString(self, attrs: list[str] | None = None) -> str: ...
-    def __eq__(self, morsel: object) -> bool: ...
-    def __setitem__(self, K: str, V: Any) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-class BaseCookie(dict[str, Morsel[_T]], Generic[_T]):
-    def __init__(self, input: _DataType | None = None) -> None: ...
-    def value_decode(self, val: str) -> tuple[_T, str]: ...
-    def value_encode(self, val: _T) -> tuple[_T, str]: ...
-    def output(self, attrs: list[str] | None = None, header: str = "Set-Cookie:", sep: str = "\r\n") -> str: ...
-    __str__ = output
-    def js_output(self, attrs: list[str] | None = None) -> str: ...
-    def load(self, rawdata: _DataType) -> None: ...
-    def __setitem__(self, key: str, value: str | Morsel[_T]) -> None: ...
-
-class SimpleCookie(BaseCookie[str]): ...

jaclang/vendor/mypy/typeshed/stdlib/http/server.pyi

@@ -1,83 +0,0 @@
-import _socket
-import email.message
-import io
-import socketserver
-import sys
-from _typeshed import StrPath, SupportsRead, SupportsWrite
-from collections.abc import Mapping, Sequence
-from typing import Any, AnyStr, BinaryIO, ClassVar
-
-__all__ = ["HTTPServer", "ThreadingHTTPServer", "BaseHTTPRequestHandler", "SimpleHTTPRequestHandler", "CGIHTTPRequestHandler"]
-
-class HTTPServer(socketserver.TCPServer):
-    server_name: str
-    server_port: int
-
-class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer): ...
-
-class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
-    client_address: tuple[str, int]
-    close_connection: bool
-    requestline: str
-    command: str
-    path: str
-    request_version: str
-    headers: email.message.Message
-    server_version: str
-    sys_version: str
-    error_message_format: str
-    error_content_type: str
-    protocol_version: str
-    MessageClass: type
-    responses: Mapping[int, tuple[str, str]]
-    default_request_version: str  # undocumented
-    weekdayname: ClassVar[Sequence[str]]  # undocumented
-    monthname: ClassVar[Sequence[str | None]]  # undocumented
-    def handle_one_request(self) -> None: ...
-    def handle_expect_100(self) -> bool: ...
-    def send_error(self, code: int, message: str | None = None, explain: str | None = None) -> None: ...
-    def send_response(self, code: int, message: str | None = None) -> None: ...
-    def send_header(self, keyword: str, value: str) -> None: ...
-    def send_response_only(self, code: int, message: str | None = None) -> None: ...
-    def end_headers(self) -> None: ...
-    def flush_headers(self) -> None: ...
-    def log_request(self, code: int | str = "-", size: int | str = "-") -> None: ...
-    def log_error(self, format: str, *args: Any) -> None: ...
-    def log_message(self, format: str, *args: Any) -> None: ...
-    def version_string(self) -> str: ...
-    def date_time_string(self, timestamp: float | None = None) -> str: ...
-    def log_date_time_string(self) -> str: ...
-    def address_string(self) -> str: ...
-    def parse_request(self) -> bool: ...  # undocumented
-
-class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
-    extensions_map: dict[str, str]
-    if sys.version_info >= (3, 12):
-        index_pages: ClassVar[tuple[str, ...]]
-    directory: str
-    def __init__(
-        self,
-        request: socketserver._RequestType,
-        client_address: _socket._RetAddress,
-        server: socketserver.BaseServer,
-        *,
-        directory: str | None = None,
-    ) -> None: ...
-    def do_GET(self) -> None: ...
-    def do_HEAD(self) -> None: ...
-    def send_head(self) -> io.BytesIO | BinaryIO | None: ...  # undocumented
-    def list_directory(self, path: StrPath) -> io.BytesIO | None: ...  # undocumented
-    def translate_path(self, path: str) -> str: ...  # undocumented
-    def copyfile(self, source: SupportsRead[AnyStr], outputfile: SupportsWrite[AnyStr]) -> None: ...  # undocumented
-    def guess_type(self, path: StrPath) -> str: ...  # undocumented
-
-def executable(path: StrPath) -> bool: ...  # undocumented
-
-class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
-    cgi_directories: list[str]
-    have_fork: bool  # undocumented
-    def do_POST(self) -> None: ...
-    def is_cgi(self) -> bool: ...  # undocumented
-    def is_executable(self, path: StrPath) -> bool: ...  # undocumented
-    def is_python(self, path: StrPath) -> bool: ...  # undocumented
-    def run_cgi(self) -> None: ...  # undocumented