jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

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

@@ -1,296 +0,0 @@
-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, Literal, Protocol, overload
-from typing_extensions import Self, TypeAlias
-
-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: int  # undocumented
-MININT: int  # undocumented
-
-PARSE_ERROR: int  # undocumented
-SERVER_ERROR: int  # undocumented
-APPLICATION_ERROR: int  # undocumented
-SYSTEM_ERROR: int  # undocumented
-TRANSPORT_ERROR: int  # undocumented
-
-NOT_WELLFORMED_ERROR: int  # undocumented
-UNSUPPORTED_ENCODING: int  # undocumented
-INVALID_ENCODING_CHAR: int  # undocumented
-INVALID_XMLRPC: int  # undocumented
-METHOD_NOT_FOUND: int  # undocumented
-INVALID_METHOD_PARAMS: int  # undocumented
-INTERNAL_ERROR: 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: ...
-    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: ...
-
-def _binary(data: ReadableBuffer) -> Binary: ...  # undocumented
-
-WRAPPERS: 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:
-    # TODO: Replace 'Any' with some kind of binding
-    dispatch: dict[type[Any], 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, 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

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

@@ -1,143 +0,0 @@
-import http.server
-import pydoc
-import socketserver
-from collections.abc import Callable, Iterable, Mapping
-from re import Pattern
-from typing import Any, ClassVar, Protocol
-from typing_extensions import TypeAlias
-from xmlrpc.client import Fault, _Marshallable
-
-# The dispatch accepts anywhere from 0 to N arguments, no easy way to allow this in mypy
-class _DispatchArity0(Protocol):
-    def __call__(self) -> _Marshallable: ...
-
-class _DispatchArity1(Protocol):
-    def __call__(self, arg1: _Marshallable, /) -> _Marshallable: ...
-
-class _DispatchArity2(Protocol):
-    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, /) -> _Marshallable: ...
-
-class _DispatchArity3(Protocol):
-    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, /) -> _Marshallable: ...
-
-class _DispatchArity4(Protocol):
-    def __call__(
-        self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, arg4: _Marshallable, /
-    ) -> _Marshallable: ...
-
-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,
-        dispatch_method: Callable[[str | None, 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: ...

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

@@ -1,22 +0,0 @@
-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: ...
-
-if sys.version_info >= (3, 10):
-    class Error(Exception): ...
-
-else:
-    class error(Exception): ...
-    class Null: ...
-
-    def roj(b: Any, /) -> None: ...

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

@@ -1,20 +0,0 @@
-from collections.abc import Callable
-from pathlib import Path
-from typing import BinaryIO
-from typing_extensions import 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: ...