layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/html/parser.pyi

@@ -0,0 +1,40 @@
+from _markupbase import ParserBase
+from re import Pattern
+from typing import Final
+
+__all__ = ["HTMLParser"]
+
+class HTMLParser(ParserBase):
+    CDATA_CONTENT_ELEMENTS: Final[tuple[str, ...]]
+    # Added in Python 3.9.23, 3.10.18, 3.11.13, 3.12.11, 3.13.6
+    RCDATA_CONTENT_ELEMENTS: Final[tuple[str, ...]]
+
+    # `scripting` parameter added in Python 3.9.25, 3.10.20, 3.11.15, 3.12.13, 3.13.10, 3.14.1
+    def __init__(self, *, convert_charrefs: bool = True, scripting: bool = False) -> 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: ...
+    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 = True) -> 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
+    # `escapable` parameter added in Python 3.9.23, 3.10.18, 3.11.13, 3.12.11, 3.13.6
+    def set_cdata_mode(self, elem: str, *, escapable: bool = False) -> None: ...  # undocumented
+    rawdata: str  # undocumented
+    cdata_elem: str | None  # undocumented
+    convert_charrefs: bool  # undocumented
+    interesting: Pattern[str]  # undocumented
+    lasttag: str  # undocumented

package/analyzers/project-map-python/typeshed/stdlib/http/__init__.pyi

@@ -0,0 +1,118 @@
+import sys
+from enum import IntEnum
+
+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: ...
+
+    # Keep these synced with the global constants in http/client.pyi.
+    CONTINUE = 100
+    SWITCHING_PROTOCOLS = 101
+    PROCESSING = 102
+    EARLY_HINTS = 103
+
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NON_AUTHORITATIVE_INFORMATION = 203
+    NO_CONTENT = 204
+    RESET_CONTENT = 205
+    PARTIAL_CONTENT = 206
+    MULTI_STATUS = 207
+    ALREADY_REPORTED = 208
+    IM_USED = 226
+
+    MULTIPLE_CHOICES = 300
+    MOVED_PERMANENTLY = 301
+    FOUND = 302
+    SEE_OTHER = 303
+    NOT_MODIFIED = 304
+    USE_PROXY = 305
+    TEMPORARY_REDIRECT = 307
+    PERMANENT_REDIRECT = 308
+
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    if sys.version_info >= (3, 13):
+        CONTENT_TOO_LARGE = 413
+    REQUEST_ENTITY_TOO_LARGE = 413
+    if sys.version_info >= (3, 13):
+        URI_TOO_LONG = 414
+    REQUEST_URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    if sys.version_info >= (3, 13):
+        RANGE_NOT_SATISFIABLE = 416
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    IM_A_TEAPOT = 418
+    MISDIRECTED_REQUEST = 421
+    if sys.version_info >= (3, 13):
+        UNPROCESSABLE_CONTENT = 422
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    TOO_EARLY = 425
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+
+    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 = "CONNECT"
+        DELETE = "DELETE"
+        GET = "GET"
+        HEAD = "HEAD"
+        OPTIONS = "OPTIONS"
+        PATCH = "PATCH"
+        POST = "POST"
+        PUT = "PUT"
+        TRACE = "TRACE"

package/analyzers/project-map-python/typeshed/stdlib/http/client.pyi

@@ -0,0 +1,318 @@
+import email.message
+import io
+import ssl
+import sys
+import types
+from _typeshed import MaybeNone, ReadableBuffer, StrOrBytesPath, SupportsRead, SupportsReadline, WriteableBuffer
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from email._policybase import _MessageT
+from socket import socket
+from typing import BinaryIO, Final, TypeAlias, TypeVar, overload
+from typing_extensions import Self, deprecated
+
+__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")
+_HeaderValue: TypeAlias = ReadableBuffer | str | int
+
+HTTP_PORT: Final = 80
+HTTPS_PORT: Final = 443
+
+# Keep these global constants in sync with http.HTTPStatus (http/__init__.pyi).
+# They are present for backward compatibility reasons.
+CONTINUE: Final = 100
+SWITCHING_PROTOCOLS: Final = 101
+PROCESSING: Final = 102
+EARLY_HINTS: Final = 103
+
+OK: Final = 200
+CREATED: Final = 201
+ACCEPTED: Final = 202
+NON_AUTHORITATIVE_INFORMATION: Final = 203
+NO_CONTENT: Final = 204
+RESET_CONTENT: Final = 205
+PARTIAL_CONTENT: Final = 206
+MULTI_STATUS: Final = 207
+ALREADY_REPORTED: Final = 208
+IM_USED: Final = 226
+
+MULTIPLE_CHOICES: Final = 300
+MOVED_PERMANENTLY: Final = 301
+FOUND: Final = 302
+SEE_OTHER: Final = 303
+NOT_MODIFIED: Final = 304
+USE_PROXY: Final = 305
+TEMPORARY_REDIRECT: Final = 307
+PERMANENT_REDIRECT: Final = 308
+
+BAD_REQUEST: Final = 400
+UNAUTHORIZED: Final = 401
+PAYMENT_REQUIRED: Final = 402
+FORBIDDEN: Final = 403
+NOT_FOUND: Final = 404
+METHOD_NOT_ALLOWED: Final = 405
+NOT_ACCEPTABLE: Final = 406
+PROXY_AUTHENTICATION_REQUIRED: Final = 407
+REQUEST_TIMEOUT: Final = 408
+CONFLICT: Final = 409
+GONE: Final = 410
+LENGTH_REQUIRED: Final = 411
+PRECONDITION_FAILED: Final = 412
+if sys.version_info >= (3, 13):
+    CONTENT_TOO_LARGE: Final = 413
+REQUEST_ENTITY_TOO_LARGE: Final = 413
+if sys.version_info >= (3, 13):
+    URI_TOO_LONG: Final = 414
+REQUEST_URI_TOO_LONG: Final = 414
+UNSUPPORTED_MEDIA_TYPE: Final = 415
+if sys.version_info >= (3, 13):
+    RANGE_NOT_SATISFIABLE: Final = 416
+REQUESTED_RANGE_NOT_SATISFIABLE: Final = 416
+EXPECTATION_FAILED: Final = 417
+IM_A_TEAPOT: Final = 418
+MISDIRECTED_REQUEST: Final = 421
+if sys.version_info >= (3, 13):
+    UNPROCESSABLE_CONTENT: Final = 422
+UNPROCESSABLE_ENTITY: Final = 422
+LOCKED: Final = 423
+FAILED_DEPENDENCY: Final = 424
+TOO_EARLY: Final = 425
+UPGRADE_REQUIRED: Final = 426
+PRECONDITION_REQUIRED: Final = 428
+TOO_MANY_REQUESTS: Final = 429
+REQUEST_HEADER_FIELDS_TOO_LARGE: Final = 431
+UNAVAILABLE_FOR_LEGAL_REASONS: Final = 451
+
+INTERNAL_SERVER_ERROR: Final = 500
+NOT_IMPLEMENTED: Final = 501
+BAD_GATEWAY: Final = 502
+SERVICE_UNAVAILABLE: Final = 503
+GATEWAY_TIMEOUT: Final = 504
+HTTP_VERSION_NOT_SUPPORTED: Final = 505
+VARIANT_ALSO_NEGOTIATES: Final = 506
+INSUFFICIENT_STORAGE: Final = 507
+LOOP_DETECTED: Final = 508
+NOT_EXTENDED: Final = 510
+NETWORK_AUTHENTICATION_REQUIRED: Final = 511
+
+responses: dict[int, str]
+
+class HTTPMessage(email.message.Message[str, str]):
+    def getallmatchingheaders(self, name: str) -> list[str]: ...  # undocumented
+
+@overload
+def parse_headers(fp: SupportsReadline[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def parse_headers(fp: SupportsReadline[bytes]) -> 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: ...
+    @deprecated("Deprecated since Python 3.9. Use `HTTPResponse.headers` attribute instead.")
+    def info(self) -> HTTPMessage: ...
+    @deprecated("Deprecated since Python 3.9. Use `HTTPResponse.url` attribute instead.")
+    def geturl(self) -> str: ...
+    @deprecated("Deprecated since Python 3.9. Use `HTTPResponse.status` attribute instead.")
+    def getcode(self) -> int: ...
+    def begin(self) -> None: ...
+
+class HTTPConnection:
+    blocksize: int
+    auto_open: int  # undocumented
+    debuglevel: int
+    default_port: int  # undocumented
+    response_class: type[HTTPResponse]  # undocumented
+    timeout: float | None
+    host: str
+    port: int
+    sock: socket | MaybeNone  # can be `None` if `.connect()` was not called
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            blocksize: int = 8192,
+            *,
+            max_response_headers: int | None = None,
+        ) -> None: ...
+    else:
+        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, _HeaderValue] = {},
+        *,
+        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, *values: _HeaderValue) -> 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 | MaybeNone
+    if sys.version_info >= (3, 15):
+        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,
+            max_response_headers: int | None = None,
+        ) -> None: ...
+    elif 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:
+        @overload
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            key_file: None = None,
+            cert_file: None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            context: ssl.SSLContext | None = None,
+            check_hostname: None = None,
+            blocksize: int = 8192,
+        ) -> None: ...
+        @overload
+        @deprecated(
+            "The `key_file`, `cert_file`, `check_hostname` parameters are deprecated since Python 3.6; "
+            "removed in Python 3.12. Use `context` parameter instead."
+        )
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            key_file: StrOrBytesPath | None = None,
+            cert_file: StrOrBytesPath | 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: ...
+
+        key_file: StrOrBytesPath | None
+        cert_file: StrOrBytesPath | 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): ...

package/analyzers/project-map-python/typeshed/stdlib/http/cookiejar.pyi

@@ -0,0 +1,158 @@
+from _typeshed import StrPath
+from collections.abc import 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:
+    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 | None
+    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): ...
+
+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: ...

package/analyzers/project-map-python/typeshed/stdlib/http/cookies.pyi

@@ -0,0 +1,53 @@
+from _typeshed import MaybeNone, SupportsItems, SupportsKeysAndGetItem
+from collections.abc import Container, Iterable
+from types import GenericAlias
+from typing import Any, Generic, TypeVar, overload
+
+__all__ = ["CookieError", "BaseCookie", "SimpleCookie"]
+
+_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 | MaybeNone: ...
+    @property
+    def coded_value(self) -> _T | MaybeNone: ...
+    @property
+    def key(self) -> str | MaybeNone: ...
+    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
+    def update(self, values: Iterable[tuple[str, str]] | SupportsKeysAndGetItem[str, str]) -> None: ...  # type: ignore[override]
+    def isReservedKey(self, K: str) -> bool: ...
+    def output(self, attrs: Container[str] | None = None, header: str = "Set-Cookie:") -> str: ...
+    __str__ = output
+    def js_output(self, attrs: Container[str] | None = None) -> str: ...
+    def OutputString(self, attrs: Container[str] | None = None) -> str: ...
+    def __eq__(self, morsel: object) -> bool: ...
+    def __setitem__(self, K: str, V: Any) -> None: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+class BaseCookie(dict[str, Morsel[_T]], Generic[_T]):
+    def __init__(self, input: str | SupportsItems[str, str | Morsel[Any]] | None = None) -> None: ...
+    def value_decode(self, val: str) -> tuple[_T, str]: ...
+    def value_encode(self, val: _T) -> tuple[str, str]: ...
+    def output(self, attrs: Container[str] | None = None, header: str = "Set-Cookie:", sep: str = "\r\n") -> str: ...
+    __str__ = output
+    def js_output(self, attrs: Container[str] | None = None) -> str: ...
+    def load(self, rawdata: str | SupportsItems[str, str | Morsel[Any]]) -> None: ...
+    def __setitem__(self, key: str, value: str | Morsel[_T]) -> None: ...
+
+class SimpleCookie(BaseCookie[str]): ...