layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/urllib/request.pyi

@@ -0,0 +1,443 @@
+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, Literal, NoReturn, Protocol, TypeAlias, TypeVar, overload, type_check_only
+from typing_extensions import deprecated
+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",
+    "HTTPSHandler",
+]
+if sys.version_info < (3, 14):
+    __all__ += ["URLopener", "FancyURLopener"]
+
+_T = TypeVar("_T")
+
+# The actual type is `addinfourl | HTTPResponse`, but users would need to use `typing.cast` or `isinstance` to narrow the type,
+# so we use `Any` instead.
+# See
+# - https://github.com/python/typeshed/pull/15042
+# - https://github.com/python/typing/issues/566
+_UrlopenRet: TypeAlias = Any
+
+_DataType: TypeAlias = ReadableBuffer | SupportsRead[bytes] | Iterable[bytes] | None
+
+if sys.version_info >= (3, 13):
+    def urlopen(
+        url: str | Request, data: _DataType | None = None, timeout: float | None = ..., *, context: ssl.SSLContext | None = None
+    ) -> _UrlopenRet: ...
+
+else:
+    @overload
+    def urlopen(
+        url: str | Request,
+        data: _DataType | None = None,
+        timeout: float | None = ...,
+        *,
+        cafile: None = None,
+        capath: None = None,
+        cadefault: Literal[False] = False,
+        context: ssl.SSLContext | None = None,
+    ) -> _UrlopenRet: ...
+    @overload
+    @deprecated(
+        "The `cafile`, `capath`, `cadefault` parameters are deprecated since Python 3.6; "
+        "removed in Python 3.13. Use `context` parameter instead."
+    )
+    def urlopen(
+        url: str | Request,
+        data: _DataType | None = None,
+        timeout: float | None = ...,
+        *,
+        cafile: StrOrBytesPath | None = None,
+        capath: StrOrBytesPath | None = None,
+        cadefault: bool = False,
+        context: None = None,
+    ) -> _UrlopenRet: ...
+
+def install_opener(opener: OpenerDirector | None) -> None: ...
+def build_opener(*handlers: BaseHandler | Callable[[], BaseHandler]) -> OpenerDirector: ...
+
+if sys.version_info >= (3, 14):
+    def url2pathname(url: str, *, require_scheme: bool = False, resolve_host: bool = False) -> str: ...
+    def pathname2url(pathname: str, *, add_scheme: bool = False) -> str: ...
+
+else:
+    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 getproxies_environment() -> 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: ...
+
+@type_check_only
+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: ...
+
+if sys.version_info < (3, 14):
+    @deprecated("Deprecated since Python 3.3; removed in Python 3.14. Use newer `urlopen` functions and methods.")
+    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: ...
+
+    @deprecated("Deprecated since Python 3.3; removed in Python 3.14. Use newer `urlopen` functions and methods.")
+    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

package/analyzers/project-map-python/typeshed/stdlib/urllib/response.pyi

@@ -0,0 +1,45 @@
+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
+from typing_extensions import deprecated
+
+__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  # Deprecated since Python 3.9. Use `addinfourl.status` attribute instead.
+    @property
+    def status(self) -> int | None: ...
+    def __init__(self, fp: IO[bytes], headers: Message, url: str, code: int | None = None) -> None: ...
+    @deprecated("Deprecated since Python 3.9. Use `addinfourl.url` attribute instead.")
+    def geturl(self) -> str: ...
+    @deprecated("Deprecated since Python 3.9. Use `addinfourl.headers` attribute instead.")
+    def info(self) -> Message: ...
+    @deprecated("Deprecated since Python 3.9. Use `addinfourl.status` attribute instead.")
+    def getcode(self) -> int | None: ...

package/analyzers/project-map-python/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: ...

package/analyzers/project-map-python/typeshed/stdlib/uu.pyi

@@ -0,0 +1,12 @@
+from typing import BinaryIO, 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: ...

package/analyzers/project-map-python/typeshed/stdlib/uuid.pyi

@@ -0,0 +1,106 @@
+import builtins
+import sys
+from _typeshed import Unused
+from enum import Enum
+from typing import Final, NoReturn, TypeAlias
+from typing_extensions import LiteralString
+
+_FieldsType: TypeAlias = tuple[int, int, int, int, int, int]
+
+class SafeUUID(Enum):
+    safe = 0
+    unsafe = -1
+    unknown = None
+
+class UUID:
+    __slots__ = ("int", "is_safe", "__weakref__")
+    is_safe: Final[SafeUUID]
+    int: Final[builtins.int]
+
+    def __init__(
+        self,
+        hex: str | None = None,
+        bytes: builtins.bytes | None = None,
+        bytes_le: builtins.bytes | None = None,
+        fields: _FieldsType | None = None,
+        int: builtins.int | None = None,
+        version: builtins.int | None = None,
+        *,
+        is_safe: SafeUUID = SafeUUID.unknown,
+    ) -> None: ...
+    @property
+    def bytes(self) -> builtins.bytes: ...
+    @property
+    def bytes_le(self) -> builtins.bytes: ...
+    @property
+    def clock_seq(self) -> builtins.int: ...
+    @property
+    def clock_seq_hi_variant(self) -> builtins.int: ...
+    @property
+    def clock_seq_low(self) -> builtins.int: ...
+    @property
+    def fields(self) -> _FieldsType: ...
+    @property
+    def hex(self) -> str: ...
+    @property
+    def node(self) -> builtins.int: ...
+    @property
+    def time(self) -> builtins.int: ...
+    @property
+    def time_hi_version(self) -> builtins.int: ...
+    @property
+    def time_low(self) -> builtins.int: ...
+    @property
+    def time_mid(self) -> builtins.int: ...
+    @property
+    def urn(self) -> str: ...
+    @property
+    def variant(self) -> str: ...
+    @property
+    def version(self) -> builtins.int | None: ...
+    def __int__(self) -> builtins.int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: UUID) -> bool: ...
+    def __le__(self, other: UUID) -> bool: ...
+    def __gt__(self, other: UUID) -> bool: ...
+    def __ge__(self, other: UUID) -> bool: ...
+    def __hash__(self) -> builtins.int: ...
+    def __setattr__(self, name: Unused, value: Unused) -> NoReturn: ...
+
+def getnode() -> int: ...
+def uuid1(node: int | None = None, clock_seq: int | None = None) -> UUID: ...
+
+if sys.version_info >= (3, 14):
+    def uuid6(node: int | None = None, clock_seq: int | None = None) -> UUID: ...
+    def uuid7() -> UUID: ...
+    def uuid8(a: int | None = None, b: int | None = None, c: int | None = None) -> UUID: ...
+
+if sys.version_info >= (3, 12):
+    def uuid3(namespace: UUID, name: str | bytes) -> UUID: ...
+
+else:
+    def uuid3(namespace: UUID, name: str) -> UUID: ...
+
+def uuid4() -> UUID: ...
+
+if sys.version_info >= (3, 12):
+    def uuid5(namespace: UUID, name: str | bytes) -> UUID: ...
+
+else:
+    def uuid5(namespace: UUID, name: str) -> UUID: ...
+
+if sys.version_info >= (3, 14):
+    NIL: Final[UUID]
+    MAX: Final[UUID]
+
+NAMESPACE_DNS: Final[UUID]
+NAMESPACE_URL: Final[UUID]
+NAMESPACE_OID: Final[UUID]
+NAMESPACE_X500: Final[UUID]
+RESERVED_NCS: Final[LiteralString]
+RFC_4122: Final[LiteralString]
+RESERVED_MICROSOFT: Final[LiteralString]
+RESERVED_FUTURE: Final[LiteralString]
+
+if sys.version_info >= (3, 12):
+    def main() -> None: ...