jaclang 0.6.0__py3-none-any.whl → 0.6.5__py3-none-any.whl

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

@@ -0,0 +1,42 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterator
+from typing import AnyStr
+
+__all__ = ["escape", "glob", "iglob"]
+
+def glob0(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
+def glob1(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
+
+if sys.version_info >= (3, 11):
+    def glob(
+        pathname: AnyStr,
+        *,
+        root_dir: StrOrBytesPath | None = None,
+        dir_fd: int | None = None,
+        recursive: bool = False,
+        include_hidden: bool = False,
+    ) -> list[AnyStr]: ...
+    def iglob(
+        pathname: AnyStr,
+        *,
+        root_dir: StrOrBytesPath | None = None,
+        dir_fd: int | None = None,
+        recursive: bool = False,
+        include_hidden: bool = False,
+    ) -> Iterator[AnyStr]: ...
+
+elif sys.version_info >= (3, 10):
+    def glob(
+        pathname: AnyStr, *, root_dir: StrOrBytesPath | None = None, dir_fd: int | None = None, recursive: bool = False
+    ) -> list[AnyStr]: ...
+    def iglob(
+        pathname: AnyStr, *, root_dir: StrOrBytesPath | None = None, dir_fd: int | None = None, recursive: bool = False
+    ) -> Iterator[AnyStr]: ...
+
+else:
+    def glob(pathname: AnyStr, *, recursive: bool = False) -> list[AnyStr]: ...
+    def iglob(pathname: AnyStr, *, recursive: bool = False) -> Iterator[AnyStr]: ...
+
+def escape(pathname: AnyStr) -> AnyStr: ...
+def has_magic(s: str | bytes) -> bool: ...  # undocumented

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

@@ -0,0 +1,28 @@
+import sys
+from _typeshed import SupportsItems
+from collections.abc import Iterable
+from typing import Any, Generic, TypeVar, overload
+
+__all__ = ["TopologicalSorter", "CycleError"]
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 11):
+    from types import GenericAlias
+
+class TopologicalSorter(Generic[_T]):
+    @overload
+    def __init__(self, graph: None = None) -> None: ...
+    @overload
+    def __init__(self, graph: SupportsItems[_T, Iterable[_T]]) -> None: ...
+    def add(self, node: _T, *predecessors: _T) -> None: ...
+    def prepare(self) -> None: ...
+    def is_active(self) -> bool: ...
+    def __bool__(self) -> bool: ...
+    def done(self, *nodes: _T) -> None: ...
+    def get_ready(self) -> tuple[_T, ...]: ...
+    def static_order(self) -> Iterable[_T]: ...
+    if sys.version_info >= (3, 11):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class CycleError(ValueError): ...

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

@@ -0,0 +1,22 @@
+import sys
+from _typeshed import structseq
+from typing import Any, Final, final
+
+if sys.platform != "win32":
+    @final
+    class struct_group(structseq[Any], tuple[str, str | None, int, list[str]]):
+        if sys.version_info >= (3, 10):
+            __match_args__: Final = ("gr_name", "gr_passwd", "gr_gid", "gr_mem")
+
+        @property
+        def gr_name(self) -> str: ...
+        @property
+        def gr_passwd(self) -> str | None: ...
+        @property
+        def gr_gid(self) -> int: ...
+        @property
+        def gr_mem(self) -> list[str]: ...
+
+    def getgrall() -> list[struct_group]: ...
+    def getgrgid(id: int) -> struct_group: ...
+    def getgrnam(name: str) -> struct_group: ...

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

@@ -0,0 +1,160 @@
+import _compression
+import sys
+import zlib
+from _typeshed import ReadableBuffer, SizedBuffer, StrOrBytesPath
+from io import FileIO
+from typing import Literal, Protocol, TextIO, overload
+from typing_extensions import TypeAlias
+
+__all__ = ["BadGzipFile", "GzipFile", "open", "compress", "decompress"]
+
+_ReadBinaryMode: TypeAlias = Literal["r", "rb"]
+_WriteBinaryMode: TypeAlias = Literal["a", "ab", "w", "wb", "x", "xb"]
+_OpenTextMode: TypeAlias = Literal["rt", "at", "wt", "xt"]
+
+READ: Literal[1]  # undocumented
+WRITE: Literal[2]  # undocumented
+
+FTEXT: int  # actually Literal[1] # undocumented
+FHCRC: int  # actually Literal[2] # undocumented
+FEXTRA: int  # actually Literal[4] # undocumented
+FNAME: int  # actually Literal[8] # undocumented
+FCOMMENT: int  # actually Literal[16] # undocumented
+
+class _ReadableFileobj(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    def seek(self, n: int, /) -> object: ...
+    # The following attributes and methods are optional:
+    # name: str
+    # mode: str
+    # def fileno() -> int: ...
+
+class _WritableFileobj(Protocol):
+    def write(self, b: bytes, /) -> object: ...
+    def flush(self) -> object: ...
+    # The following attributes and methods are optional:
+    # name: str
+    # mode: str
+    # def fileno() -> int: ...
+
+@overload
+def open(
+    filename: StrOrBytesPath | _ReadableFileobj,
+    mode: _ReadBinaryMode = "rb",
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> GzipFile: ...
+@overload
+def open(
+    filename: StrOrBytesPath | _WritableFileobj,
+    mode: _WriteBinaryMode,
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> GzipFile: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: _OpenTextMode,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIO: ...
+@overload
+def open(
+    filename: StrOrBytesPath | _ReadableFileobj | _WritableFileobj,
+    mode: str,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> GzipFile | TextIO: ...
+
+class _PaddedFile:
+    file: _ReadableFileobj
+    def __init__(self, f: _ReadableFileobj, prepend: bytes = b"") -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def prepend(self, prepend: bytes = b"") -> None: ...
+    def seek(self, off: int) -> int: ...
+    def seekable(self) -> bool: ...
+
+class BadGzipFile(OSError): ...
+
+class GzipFile(_compression.BaseStream):
+    myfileobj: FileIO | None
+    mode: Literal[1, 2]
+    name: str
+    compress: zlib._Compress
+    fileobj: _ReadableFileobj | _WritableFileobj
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None,
+        mode: _ReadBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        *,
+        mode: _ReadBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None,
+        mode: _WriteBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        *,
+        mode: _WriteBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None = None,
+        mode: str | None = None,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    if sys.version_info < (3, 12):
+        @property
+        def filename(self) -> str: ...
+
+    @property
+    def mtime(self) -> int | None: ...
+    crc: int
+    def write(self, data: ReadableBuffer) -> int: ...
+    def read(self, size: int | None = -1) -> bytes: ...
+    def read1(self, size: int = -1) -> bytes: ...
+    def peek(self, n: int) -> bytes: ...
+    def close(self) -> None: ...
+    def flush(self, zlib_mode: int = 2) -> None: ...
+    def fileno(self) -> int: ...
+    def rewind(self) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+    def readline(self, size: int | None = -1) -> bytes: ...
+
+class _GzipReader(_compression.DecompressReader):
+    def __init__(self, fp: _ReadableFileobj) -> None: ...
+
+def compress(data: SizedBuffer, compresslevel: int = 9, *, mtime: float | None = None) -> bytes: ...
+def decompress(data: ReadableBuffer) -> bytes: ...

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

@@ -0,0 +1,167 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable, Set as AbstractSet
+from typing import Protocol, final
+from typing_extensions import Self
+
+if sys.version_info >= (3, 11):
+    __all__ = (
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "blake2b",
+        "blake2s",
+        "sha3_224",
+        "sha3_256",
+        "sha3_384",
+        "sha3_512",
+        "shake_128",
+        "shake_256",
+        "new",
+        "algorithms_guaranteed",
+        "algorithms_available",
+        "pbkdf2_hmac",
+        "file_digest",
+    )
+else:
+    __all__ = (
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "blake2b",
+        "blake2s",
+        "sha3_224",
+        "sha3_256",
+        "sha3_384",
+        "sha3_512",
+        "shake_128",
+        "shake_256",
+        "new",
+        "algorithms_guaranteed",
+        "algorithms_available",
+        "pbkdf2_hmac",
+    )
+
+class _Hash:
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...
+
+if sys.version_info >= (3, 9):
+    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> _Hash: ...
+    def md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+
+else:
+    def new(name: str, data: ReadableBuffer = b"") -> _Hash: ...
+    def md5(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha1(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha224(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha256(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha384(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha512(string: ReadableBuffer = b"") -> _Hash: ...
+
+algorithms_guaranteed: AbstractSet[str]
+algorithms_available: AbstractSet[str]
+
+def pbkdf2_hmac(
+    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
+) -> bytes: ...
+
+class _VarLenHash:
+    digest_size: int
+    block_size: int
+    name: str
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> _VarLenHash: ...
+    def digest(self, length: int, /) -> bytes: ...
+    def hexdigest(self, length: int, /) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...
+
+sha3_224 = _Hash
+sha3_256 = _Hash
+sha3_384 = _Hash
+sha3_512 = _Hash
+shake_128 = _VarLenHash
+shake_256 = _VarLenHash
+
+def scrypt(
+    password: ReadableBuffer, *, salt: ReadableBuffer, n: int, r: int, p: int, maxmem: int = 0, dklen: int = 64
+) -> bytes: ...
+@final
+class _BlakeHash(_Hash):
+    MAX_DIGEST_SIZE: int
+    MAX_KEY_SIZE: int
+    PERSON_SIZE: int
+    SALT_SIZE: int
+
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            data: ReadableBuffer = ...,
+            /,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+            usedforsecurity: bool = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            data: ReadableBuffer = ...,
+            /,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+        ) -> None: ...
+
+blake2b = _BlakeHash
+blake2s = _BlakeHash
+
+if sys.version_info >= (3, 11):
+    class _BytesIOLike(Protocol):
+        def getbuffer(self) -> ReadableBuffer: ...
+
+    class _FileDigestFileObj(Protocol):
+        def readinto(self, buf: bytearray, /) -> int: ...
+        def readable(self) -> bool: ...
+
+    def file_digest(
+        fileobj: _BytesIOLike | _FileDigestFileObj, digest: str | Callable[[], _Hash], /, *, _bufsize: int = 262144
+    ) -> _Hash: ...

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

@@ -0,0 +1,17 @@
+from _heapq import *
+from _typeshed import SupportsRichComparison
+from collections.abc import Callable, Iterable
+from typing import Any, Final, TypeVar
+
+__all__ = ["heappush", "heappop", "heapify", "heapreplace", "merge", "nlargest", "nsmallest", "heappushpop"]
+
+_S = TypeVar("_S")
+
+__about__: Final[str]
+
+def merge(
+    *iterables: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None, reverse: bool = False
+) -> Iterable[_S]: ...
+def nlargest(n: int, iterable: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None) -> list[_S]: ...
+def nsmallest(n: int, iterable: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None) -> list[_S]: ...
+def _heapify_max(heap: list[Any], /) -> None: ...  # undocumented

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

@@ -0,0 +1,38 @@
+from _typeshed import ReadableBuffer, SizedBuffer
+from collections.abc import Callable
+from types import ModuleType
+from typing import Any, AnyStr, overload
+from typing_extensions import TypeAlias
+
+# TODO more precise type for object of hashlib
+_Hash: TypeAlias = Any
+_DigestMod: TypeAlias = str | Callable[[], _Hash] | ModuleType
+
+trans_5C: bytes
+trans_36: bytes
+
+digest_size: None
+
+# In reality digestmod has a default value, but the function always throws an error
+# if the argument is not given, so we pretend it is a required argument.
+@overload
+def new(key: bytes | bytearray, msg: ReadableBuffer | None, digestmod: _DigestMod) -> HMAC: ...
+@overload
+def new(key: bytes | bytearray, *, digestmod: _DigestMod) -> HMAC: ...
+
+class HMAC:
+    digest_size: int
+    block_size: int
+    @property
+    def name(self) -> str: ...
+    def __init__(self, key: bytes | bytearray, msg: ReadableBuffer | None = None, digestmod: _DigestMod = "") -> None: ...
+    def update(self, msg: ReadableBuffer) -> None: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def copy(self) -> HMAC: ...
+
+@overload
+def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+@overload
+def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...

jaclang/vendor/mypy/typeshed/stdlib/html/__init__.pyi

@@ -0,0 +1,6 @@
+from typing import AnyStr
+
+__all__ = ["escape", "unescape"]
+
+def escape(s: AnyStr, quote: bool = True) -> AnyStr: ...
+def unescape(s: AnyStr) -> AnyStr: ...

jaclang/vendor/mypy/typeshed/stdlib/html/entities.pyi

@@ -0,0 +1,6 @@
+__all__ = ["html5", "name2codepoint", "codepoint2name", "entitydefs"]
+
+name2codepoint: dict[str, int]
+html5: dict[str, str]
+codepoint2name: dict[int, str]
+entitydefs: dict[str, str]

jaclang/vendor/mypy/typeshed/stdlib/html/parser.pyi

@@ -0,0 +1,34 @@
+from _markupbase import ParserBase
+from re import Pattern
+
+__all__ = ["HTMLParser"]
+
+class HTMLParser(ParserBase):
+    def __init__(self, *, convert_charrefs: bool = True) -> None: ...
+    def feed(self, data: str) -> None: ...
+    def close(self) -> None: ...
+    def get_starttag_text(self) -> str | None: ...
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None: ...
+    def handle_endtag(self, tag: str) -> None: ...
+    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None: ...
+    def handle_data(self, data: str) -> None: ...
+    def handle_entityref(self, name: str) -> None: ...
+    def handle_charref(self, name: str) -> None: ...
+    def handle_comment(self, data: str) -> None: ...
+    def handle_decl(self, decl: str) -> None: ...
+    def handle_pi(self, data: str) -> None: ...
+    CDATA_CONTENT_ELEMENTS: tuple[str, ...]
+    def check_for_whole_start_tag(self, i: int) -> int: ...  # undocumented
+    def clear_cdata_mode(self) -> None: ...  # undocumented
+    def goahead(self, end: bool) -> None: ...  # undocumented
+    def parse_bogus_comment(self, i: int, report: bool = ...) -> int: ...  # undocumented
+    def parse_endtag(self, i: int) -> int: ...  # undocumented
+    def parse_html_declaration(self, i: int) -> int: ...  # undocumented
+    def parse_pi(self, i: int) -> int: ...  # undocumented
+    def parse_starttag(self, i: int) -> int: ...  # undocumented
+    def set_cdata_mode(self, elem: str) -> None: ...  # undocumented
+    rawdata: str  # undocumented
+    cdata_elem: str | None  # undocumented
+    convert_charrefs: bool  # undocumented
+    interesting: Pattern[str]  # undocumented
+    lasttag: str  # undocumented

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

@@ -0,0 +1,105 @@
+import sys
+from enum import IntEnum
+from typing import Literal
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+
+if sys.version_info >= (3, 11):
+    __all__ = ["HTTPStatus", "HTTPMethod"]
+else:
+    __all__ = ["HTTPStatus"]
+
+class HTTPStatus(IntEnum):
+    @property
+    def phrase(self) -> str: ...
+    @property
+    def description(self) -> str: ...
+    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
+    ALREADY_REPORTED: int
+    IM_USED: int
+    MULTIPLE_CHOICES: int
+    MOVED_PERMANENTLY: int
+    FOUND: int
+    SEE_OTHER: int
+    NOT_MODIFIED: int
+    USE_PROXY: int
+    TEMPORARY_REDIRECT: int
+    PERMANENT_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
+    VARIANT_ALSO_NEGOTIATES: int
+    INSUFFICIENT_STORAGE: int
+    LOOP_DETECTED: int
+    NOT_EXTENDED: int
+    NETWORK_AUTHENTICATION_REQUIRED: int
+    MISDIRECTED_REQUEST: int
+    UNAVAILABLE_FOR_LEGAL_REASONS: int
+    if sys.version_info >= (3, 9):
+        EARLY_HINTS: Literal[103]
+        IM_A_TEAPOT: Literal[418]
+        TOO_EARLY: Literal[425]
+    if sys.version_info >= (3, 12):
+        @property
+        def is_informational(self) -> bool: ...
+        @property
+        def is_success(self) -> bool: ...
+        @property
+        def is_redirection(self) -> bool: ...
+        @property
+        def is_client_error(self) -> bool: ...
+        @property
+        def is_server_error(self) -> bool: ...
+
+if sys.version_info >= (3, 11):
+    class HTTPMethod(StrEnum):
+        @property
+        def description(self) -> str: ...
+        CONNECT: str
+        DELETE: str
+        GET: str
+        HEAD: str
+        OPTIONS: str
+        PATCH: str
+        POST: str
+        PUT: str
+        TRACE: str