layermap 0.1.0

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

@@ -0,0 +1,300 @@
+import gzip
+import http.client
+import time
+from _typeshed import ReadableBuffer, SizedBuffer, SupportsRead, SupportsWrite
+from collections.abc import Callable, Iterable, Mapping
+from datetime import datetime
+from io import BytesIO
+from types import TracebackType
+from typing import Any, ClassVar, Final, Literal, Protocol, TypeAlias, overload, type_check_only
+from typing_extensions import Self
+
+@type_check_only
+class _SupportsTimeTuple(Protocol):
+    def timetuple(self) -> time.struct_time: ...
+
+_DateTimeComparable: TypeAlias = DateTime | datetime | str | _SupportsTimeTuple
+_Marshallable: TypeAlias = (
+    bool
+    | int
+    | float
+    | str
+    | bytes
+    | bytearray
+    | None
+    | tuple[_Marshallable, ...]
+    # Ideally we'd use _Marshallable for list and dict, but invariance makes that impractical
+    | list[Any]
+    | dict[str, Any]
+    | datetime
+    | DateTime
+    | Binary
+)
+_XMLDate: TypeAlias = int | datetime | tuple[int, ...] | time.struct_time
+_HostType: TypeAlias = tuple[str, dict[str, str]] | str
+
+def escape(s: str) -> str: ...  # undocumented
+
+MAXINT: Final[int]  # undocumented
+MININT: Final[int]  # undocumented
+
+PARSE_ERROR: Final[int]  # undocumented
+SERVER_ERROR: Final[int]  # undocumented
+APPLICATION_ERROR: Final[int]  # undocumented
+SYSTEM_ERROR: Final[int]  # undocumented
+TRANSPORT_ERROR: Final[int]  # undocumented
+
+NOT_WELLFORMED_ERROR: Final[int]  # undocumented
+UNSUPPORTED_ENCODING: Final[int]  # undocumented
+INVALID_ENCODING_CHAR: Final[int]  # undocumented
+INVALID_XMLRPC: Final[int]  # undocumented
+METHOD_NOT_FOUND: Final[int]  # undocumented
+INVALID_METHOD_PARAMS: Final[int]  # undocumented
+INTERNAL_ERROR: Final[int]  # undocumented
+
+class Error(Exception): ...
+
+class ProtocolError(Error):
+    url: str
+    errcode: int
+    errmsg: str
+    headers: dict[str, str]
+    def __init__(self, url: str, errcode: int, errmsg: str, headers: dict[str, str]) -> None: ...
+
+class ResponseError(Error): ...
+
+class Fault(Error):
+    faultCode: int
+    faultString: str
+    def __init__(self, faultCode: int, faultString: str, **extra: Any) -> None: ...
+
+boolean = bool
+Boolean = bool
+
+def _iso8601_format(value: datetime) -> str: ...  # undocumented
+def _strftime(value: _XMLDate) -> str: ...  # undocumented
+
+class DateTime:
+    value: str  # undocumented
+    def __init__(self, value: int | str | datetime | time.struct_time | tuple[int, ...] = 0) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    def __lt__(self, other: _DateTimeComparable) -> bool: ...
+    def __le__(self, other: _DateTimeComparable) -> bool: ...
+    def __gt__(self, other: _DateTimeComparable) -> bool: ...
+    def __ge__(self, other: _DateTimeComparable) -> bool: ...
+    def __eq__(self, other: _DateTimeComparable) -> bool: ...  # type: ignore[override]
+    def make_comparable(self, other: _DateTimeComparable) -> tuple[str, str]: ...  # undocumented
+    def timetuple(self) -> time.struct_time: ...  # undocumented
+    def decode(self, data: Any) -> None: ...
+    def encode(self, out: SupportsWrite[str]) -> None: ...
+
+def _datetime(data: Any) -> DateTime: ...  # undocumented
+def _datetime_type(data: str) -> datetime: ...  # undocumented
+
+class Binary:
+    data: bytes
+    def __init__(self, data: bytes | bytearray | None = None) -> None: ...
+    def decode(self, data: ReadableBuffer) -> None: ...
+    def encode(self, out: SupportsWrite[str]) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+def _binary(data: ReadableBuffer) -> Binary: ...  # undocumented
+
+WRAPPERS: Final[tuple[type[DateTime], type[Binary]]]  # undocumented
+
+class ExpatParser:  # undocumented
+    def __init__(self, target: Unmarshaller) -> None: ...
+    def feed(self, data: str | ReadableBuffer) -> None: ...
+    def close(self) -> None: ...
+
+_WriteCallback: TypeAlias = Callable[[str], object]
+
+class Marshaller:
+    dispatch: dict[type[_Marshallable] | Literal["_arbitrary_instance"], Callable[[Marshaller, Any, _WriteCallback], None]]
+    memo: dict[Any, None]
+    data: None
+    encoding: str | None
+    allow_none: bool
+    def __init__(self, encoding: str | None = None, allow_none: bool = False) -> None: ...
+    def dumps(self, values: Fault | Iterable[_Marshallable]) -> str: ...
+    def __dump(self, value: _Marshallable, write: _WriteCallback) -> None: ...  # undocumented
+    def dump_nil(self, value: None, write: _WriteCallback) -> None: ...
+    def dump_bool(self, value: bool, write: _WriteCallback) -> None: ...
+    def dump_long(self, value: int, write: _WriteCallback) -> None: ...
+    def dump_int(self, value: int, write: _WriteCallback) -> None: ...
+    def dump_double(self, value: float, write: _WriteCallback) -> None: ...
+    def dump_unicode(self, value: str, write: _WriteCallback, escape: Callable[[str], str] = ...) -> None: ...
+    def dump_bytes(self, value: ReadableBuffer, write: _WriteCallback) -> None: ...
+    def dump_array(self, value: Iterable[_Marshallable], write: _WriteCallback) -> None: ...
+    def dump_struct(
+        self, value: Mapping[str, _Marshallable], write: _WriteCallback, escape: Callable[[str], str] = ...
+    ) -> None: ...
+    def dump_datetime(self, value: _XMLDate, write: _WriteCallback) -> None: ...
+    def dump_instance(self, value: object, write: _WriteCallback) -> None: ...
+
+class Unmarshaller:
+    dispatch: dict[str, Callable[[Unmarshaller, str], None]]
+
+    _type: str | None
+    _stack: list[_Marshallable]
+    _marks: list[int]
+    _data: list[str]
+    _value: bool
+    _methodname: str | None
+    _encoding: str
+    append: Callable[[Any], None]
+    _use_datetime: bool
+    _use_builtin_types: bool
+    def __init__(self, use_datetime: bool = False, use_builtin_types: bool = False) -> None: ...
+    def close(self) -> tuple[_Marshallable, ...]: ...
+    def getmethodname(self) -> str | None: ...
+    def xml(self, encoding: str, standalone: Any) -> None: ...  # Standalone is ignored
+    def start(self, tag: str, attrs: dict[str, str]) -> None: ...
+    def data(self, text: str) -> None: ...
+    def end(self, tag: str) -> None: ...
+    def end_dispatch(self, tag: str, data: str) -> None: ...
+    def end_nil(self, data: str) -> None: ...
+    def end_boolean(self, data: str) -> None: ...
+    def end_int(self, data: str) -> None: ...
+    def end_double(self, data: str) -> None: ...
+    def end_bigdecimal(self, data: str) -> None: ...
+    def end_string(self, data: str) -> None: ...
+    def end_array(self, data: str) -> None: ...
+    def end_struct(self, data: str) -> None: ...
+    def end_base64(self, data: str) -> None: ...
+    def end_dateTime(self, data: str) -> None: ...
+    def end_value(self, data: str) -> None: ...
+    def end_params(self, data: str) -> None: ...
+    def end_fault(self, data: str) -> None: ...
+    def end_methodName(self, data: str) -> None: ...
+
+class _MultiCallMethod:  # undocumented
+    __call_list: list[tuple[str, tuple[_Marshallable, ...]]]
+    __name: str
+    def __init__(self, call_list: list[tuple[str, _Marshallable]], name: str) -> None: ...
+    def __getattr__(self, name: str) -> _MultiCallMethod: ...
+    def __call__(self, *args: _Marshallable) -> None: ...
+
+class MultiCallIterator:  # undocumented
+    results: list[list[_Marshallable]]
+    def __init__(self, results: list[list[_Marshallable]]) -> None: ...
+    def __getitem__(self, i: int) -> _Marshallable: ...
+
+class MultiCall:
+    __server: ServerProxy
+    __call_list: list[tuple[str, tuple[_Marshallable, ...]]]
+    def __init__(self, server: ServerProxy) -> None: ...
+    def __getattr__(self, name: str) -> _MultiCallMethod: ...
+    def __call__(self) -> MultiCallIterator: ...
+
+# A little white lie
+FastMarshaller: Marshaller | None
+FastParser: ExpatParser | None
+FastUnmarshaller: Unmarshaller | None
+
+def getparser(use_datetime: bool = False, use_builtin_types: bool = False) -> tuple[ExpatParser, Unmarshaller]: ...
+def dumps(
+    params: Fault | tuple[_Marshallable, ...],
+    methodname: str | None = None,
+    methodresponse: bool | None = None,
+    encoding: str | None = None,
+    allow_none: bool = False,
+) -> str: ...
+def loads(
+    data: str | ReadableBuffer, use_datetime: bool = False, use_builtin_types: bool = False
+) -> tuple[tuple[_Marshallable, ...], str | None]: ...
+def gzip_encode(data: ReadableBuffer) -> bytes: ...  # undocumented
+def gzip_decode(data: ReadableBuffer, max_decode: int = 20971520) -> bytes: ...  # undocumented
+
+class GzipDecodedResponse(gzip.GzipFile):  # undocumented
+    io: BytesIO
+    def __init__(self, response: SupportsRead[ReadableBuffer]) -> None: ...
+
+class _Method:  # undocumented
+    __send: Callable[[str, tuple[_Marshallable, ...]], _Marshallable]
+    __name: str
+    def __init__(self, send: Callable[[str, tuple[_Marshallable, ...]], _Marshallable], name: str) -> None: ...
+    def __getattr__(self, name: str) -> _Method: ...
+    def __call__(self, *args: _Marshallable) -> _Marshallable: ...
+
+class Transport:
+    user_agent: str
+    accept_gzip_encoding: bool
+    encode_threshold: int | None
+
+    _use_datetime: bool
+    _use_builtin_types: bool
+    _connection: tuple[_HostType | None, http.client.HTTPConnection | None]
+    _headers: list[tuple[str, str]]
+    _extra_headers: list[tuple[str, str]]
+
+    def __init__(
+        self, use_datetime: bool = False, use_builtin_types: bool = False, *, headers: Iterable[tuple[str, str]] = ()
+    ) -> None: ...
+    def request(
+        self, host: _HostType, handler: str, request_body: SizedBuffer, verbose: bool = False
+    ) -> tuple[_Marshallable, ...]: ...
+    def single_request(
+        self, host: _HostType, handler: str, request_body: SizedBuffer, verbose: bool = False
+    ) -> tuple[_Marshallable, ...]: ...
+    def getparser(self) -> tuple[ExpatParser, Unmarshaller]: ...
+    def get_host_info(self, host: _HostType) -> tuple[str, list[tuple[str, str]], dict[str, str]]: ...
+    def make_connection(self, host: _HostType) -> http.client.HTTPConnection: ...
+    def close(self) -> None: ...
+    def send_request(
+        self, host: _HostType, handler: str, request_body: SizedBuffer, debug: bool
+    ) -> http.client.HTTPConnection: ...
+    def send_headers(self, connection: http.client.HTTPConnection, headers: list[tuple[str, str]]) -> None: ...
+    def send_content(self, connection: http.client.HTTPConnection, request_body: SizedBuffer) -> None: ...
+    def parse_response(self, response: http.client.HTTPResponse) -> tuple[_Marshallable, ...]: ...
+
+class SafeTransport(Transport):
+    def __init__(
+        self,
+        use_datetime: bool = False,
+        use_builtin_types: bool = False,
+        *,
+        headers: Iterable[tuple[str, str]] = (),
+        context: Any | None = None,
+    ) -> None: ...
+    def make_connection(self, host: _HostType) -> http.client.HTTPSConnection: ...
+
+class ServerProxy:
+    __host: str
+    __handler: str
+    __transport: Transport
+    __encoding: str
+    __verbose: bool
+    __allow_none: bool
+
+    def __init__(
+        self,
+        uri: str,
+        transport: Transport | None = None,
+        encoding: str | None = None,
+        verbose: bool = False,
+        allow_none: bool = False,
+        use_datetime: bool = False,
+        use_builtin_types: bool = False,
+        *,
+        headers: Iterable[tuple[str, str]] = (),
+        context: Any | None = None,
+    ) -> None: ...
+    def __getattr__(self, name: str) -> _Method: ...
+
+    @overload
+    def __call__(self, attr: Literal["close"]) -> Callable[[], None]: ...
+    @overload
+    def __call__(self, attr: Literal["transport"]) -> Transport: ...
+    @overload
+    def __call__(self, attr: str) -> Callable[[], None] | Transport: ...
+
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __close(self) -> None: ...  # undocumented
+    def __request(self, methodname: str, params: tuple[_Marshallable, ...]) -> tuple[_Marshallable, ...]: ...  # undocumented
+
+Server = ServerProxy

package/analyzers/project-map-python/typeshed/stdlib/xmlrpc/server.pyi

@@ -0,0 +1,149 @@
+import http.server
+import pydoc
+import socketserver
+from _typeshed import ReadableBuffer
+from collections.abc import Callable, Iterable, Mapping
+from re import Pattern
+from typing import Any, ClassVar, Protocol, TypeAlias, type_check_only
+from xmlrpc.client import Fault, _Marshallable
+
+# The dispatch accepts anywhere from 0 to N arguments, no easy way to allow this in mypy
+@type_check_only
+class _DispatchArity0(Protocol):
+    def __call__(self) -> _Marshallable: ...
+
+@type_check_only
+class _DispatchArity1(Protocol):
+    def __call__(self, arg1: _Marshallable, /) -> _Marshallable: ...
+
+@type_check_only
+class _DispatchArity2(Protocol):
+    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, /) -> _Marshallable: ...
+
+@type_check_only
+class _DispatchArity3(Protocol):
+    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, /) -> _Marshallable: ...
+
+@type_check_only
+class _DispatchArity4(Protocol):
+    def __call__(
+        self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, arg4: _Marshallable, /
+    ) -> _Marshallable: ...
+
+@type_check_only
+class _DispatchArityN(Protocol):
+    def __call__(self, *args: _Marshallable) -> _Marshallable: ...
+
+_DispatchProtocol: TypeAlias = (
+    _DispatchArity0 | _DispatchArity1 | _DispatchArity2 | _DispatchArity3 | _DispatchArity4 | _DispatchArityN
+)
+
+def resolve_dotted_attribute(obj: Any, attr: str, allow_dotted_names: bool = True) -> Any: ...  # undocumented
+def list_public_methods(obj: Any) -> list[str]: ...  # undocumented
+
+class SimpleXMLRPCDispatcher:  # undocumented
+    funcs: dict[str, _DispatchProtocol]
+    instance: Any | None
+    allow_none: bool
+    encoding: str
+    use_builtin_types: bool
+    def __init__(self, allow_none: bool = False, encoding: str | None = None, use_builtin_types: bool = False) -> None: ...
+    def register_instance(self, instance: Any, allow_dotted_names: bool = False) -> None: ...
+    def register_function(self, function: _DispatchProtocol | None = None, name: str | None = None) -> Callable[..., Any]: ...
+    def register_introspection_functions(self) -> None: ...
+    def register_multicall_functions(self) -> None: ...
+    def _marshaled_dispatch(
+        self,
+        data: str | ReadableBuffer,
+        dispatch_method: Callable[[str, tuple[_Marshallable, ...]], Fault | tuple[_Marshallable, ...]] | None = None,
+        path: Any | None = None,
+    ) -> str: ...  # undocumented
+    def system_listMethods(self) -> list[str]: ...  # undocumented
+    def system_methodSignature(self, method_name: str) -> str: ...  # undocumented
+    def system_methodHelp(self, method_name: str) -> str: ...  # undocumented
+    def system_multicall(self, call_list: list[dict[str, _Marshallable]]) -> list[_Marshallable]: ...  # undocumented
+    def _dispatch(self, method: str, params: Iterable[_Marshallable]) -> _Marshallable: ...  # undocumented
+
+class SimpleXMLRPCRequestHandler(http.server.BaseHTTPRequestHandler):
+    rpc_paths: ClassVar[tuple[str, ...]]
+    encode_threshold: int  # undocumented
+    aepattern: Pattern[str]  # undocumented
+    def accept_encodings(self) -> dict[str, float]: ...
+    def is_rpc_path_valid(self) -> bool: ...
+    def do_POST(self) -> None: ...
+    def decode_request_content(self, data: bytes) -> bytes | None: ...
+    def report_404(self) -> None: ...
+
+class SimpleXMLRPCServer(socketserver.TCPServer, SimpleXMLRPCDispatcher):
+    _send_traceback_handler: bool
+    def __init__(
+        self,
+        addr: tuple[str, int],
+        requestHandler: type[SimpleXMLRPCRequestHandler] = ...,
+        logRequests: bool = True,
+        allow_none: bool = False,
+        encoding: str | None = None,
+        bind_and_activate: bool = True,
+        use_builtin_types: bool = False,
+    ) -> None: ...
+
+class MultiPathXMLRPCServer(SimpleXMLRPCServer):  # undocumented
+    dispatchers: dict[str, SimpleXMLRPCDispatcher]
+    def __init__(
+        self,
+        addr: tuple[str, int],
+        requestHandler: type[SimpleXMLRPCRequestHandler] = ...,
+        logRequests: bool = True,
+        allow_none: bool = False,
+        encoding: str | None = None,
+        bind_and_activate: bool = True,
+        use_builtin_types: bool = False,
+    ) -> None: ...
+    def add_dispatcher(self, path: str, dispatcher: SimpleXMLRPCDispatcher) -> SimpleXMLRPCDispatcher: ...
+    def get_dispatcher(self, path: str) -> SimpleXMLRPCDispatcher: ...
+
+class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
+    def __init__(self, allow_none: bool = False, encoding: str | None = None, use_builtin_types: bool = False) -> None: ...
+    def handle_xmlrpc(self, request_text: str) -> None: ...
+    def handle_get(self) -> None: ...
+    def handle_request(self, request_text: str | None = None) -> None: ...
+
+class ServerHTMLDoc(pydoc.HTMLDoc):  # undocumented
+    def docroutine(  # type: ignore[override]
+        self,
+        object: object,
+        name: str,
+        mod: str | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        methods: Mapping[str, str] = {},
+        cl: type | None = None,
+    ) -> str: ...
+    def docserver(self, server_name: str, package_documentation: str, methods: dict[str, str]) -> str: ...
+
+class XMLRPCDocGenerator:  # undocumented
+    server_name: str
+    server_documentation: str
+    server_title: str
+    def set_server_title(self, server_title: str) -> None: ...
+    def set_server_name(self, server_name: str) -> None: ...
+    def set_server_documentation(self, server_documentation: str) -> None: ...
+    def generate_html_documentation(self) -> str: ...
+
+class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
+    def do_GET(self) -> None: ...
+
+class DocXMLRPCServer(SimpleXMLRPCServer, XMLRPCDocGenerator):
+    def __init__(
+        self,
+        addr: tuple[str, int],
+        requestHandler: type[SimpleXMLRPCRequestHandler] = ...,
+        logRequests: bool = True,
+        allow_none: bool = False,
+        encoding: str | None = None,
+        bind_and_activate: bool = True,
+        use_builtin_types: bool = False,
+    ) -> None: ...
+
+class DocCGIXMLRPCRequestHandler(CGIXMLRPCRequestHandler, XMLRPCDocGenerator):
+    def __init__(self) -> None: ...

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

@@ -0,0 +1,15 @@
+import sys
+from typing import Any, final
+
+class Str(str): ...
+
+@final
+class Xxo:
+    def demo(self) -> None: ...
+    if sys.version_info >= (3, 11) and sys.platform != "win32":
+        x_exports: int
+
+def foo(i: int, j: int, /) -> Any: ...
+def new() -> Xxo: ...
+
+class Error(Exception): ...

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

@@ -0,0 +1,19 @@
+from collections.abc import Callable
+from pathlib import Path
+from typing import BinaryIO, TypeAlias
+
+__all__ = ["ZipAppError", "create_archive", "get_interpreter"]
+
+_Path: TypeAlias = str | Path | BinaryIO
+
+class ZipAppError(ValueError): ...
+
+def create_archive(
+    source: _Path,
+    target: _Path | None = None,
+    interpreter: str | None = None,
+    main: str | None = None,
+    filter: Callable[[Path], bool] | None = None,
+    compressed: bool = False,
+) -> None: ...
+def get_interpreter(archive: _Path) -> str: ...