From 2b40e2ffe3cdda51990979b81567764965d890ed Mon Sep 17 00:00:00 2001 From: Semyon Proshev Date: Thu, 9 Jan 2020 16:59:48 +0300 Subject: [PATCH] Enable `xml` stubs (PY-39061) GitOrigin-RevId: cbde80de3256af9b10f67851a92eec3cb0a8ce06 --- .../typeshed/stdlib/2and3/xml/__init__.pyi | 1 + .../stdlib/2and3/xml/etree/ElementInclude.pyi | 17 ++ .../stdlib/2and3/xml/etree/ElementPath.pyi | 33 +++ .../stdlib/2and3/xml/etree/ElementTree.pyi | 259 ++++++++++++++++++ .../stdlib/2and3/xml/etree/__init__.pyi | 0 .../stdlib/2and3/xml/etree/cElementTree.pyi | 3 + .../stdlib/2and3/xml/parsers/__init__.pyi | 1 + .../2and3/xml/parsers/expat/__init__.pyi | 1 + .../stdlib/2and3/xml/parsers/expat/errors.pyi | 1 + .../stdlib/2and3/xml/parsers/expat/model.pyi | 1 + .../stdlib/2and3/xml/sax/__init__.pyi | 34 +++ .../typeshed/stdlib/2and3/xml/sax/handler.pyi | 46 ++++ .../stdlib/2and3/xml/sax/saxutils.pyi | 58 ++++ .../stdlib/2and3/xml/sax/xmlreader.pyi | 71 +++++ .../jetbrains/python/tools/PyTypeShedSync.kts | 3 +- 15 files changed, 528 insertions(+), 1 deletion(-) create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/__init__.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/etree/__init__.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/parsers/__init__.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/sax/__init__.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/sax/handler.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/sax/saxutils.pyi create mode 100644 python/helpers/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi diff --git a/python/helpers/typeshed/stdlib/2and3/xml/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/xml/__init__.pyi new file mode 100644 index 000000000000..c524ac2b1cfc --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/__init__.pyi @@ -0,0 +1 @@ +import xml.parsers as parsers diff --git a/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi new file mode 100644 index 000000000000..e8c3cd5609fc --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi @@ -0,0 +1,17 @@ +# Stubs for xml.etree.ElementInclude (Python 3.4) + +from typing import Union, Optional, Callable +from xml.etree.ElementTree import Element + +XINCLUDE: str +XINCLUDE_INCLUDE: str +XINCLUDE_FALLBACK: str + +class FatalIncludeError(SyntaxError): ... + +def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str] = ...) -> Union[str, Element]: ... + +# TODO: loader is of type default_loader ie it takes a callable that has the +# same signature as default_loader. But default_loader has a keyword argument +# Which can't be represented using Callable... +def include(elem: Element, loader: Optional[Callable[..., Union[str, Element]]] = ...) -> None: ... diff --git a/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi new file mode 100644 index 000000000000..1250f0da42dd --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi @@ -0,0 +1,33 @@ +# Stubs for xml.etree.ElementPath (Python 3.4) + +from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional +from xml.etree.ElementTree import Element + +xpath_tokenizer_re: Pattern[str] + +_token = Tuple[str, str] +_next = Callable[[], _token] +_callback = Callable[[_SelectorContext, List[Element]], Generator[Element, None, None]] + +def xpath_tokenizer(pattern: str, namespaces: Optional[Dict[str, str]] = ...) -> Generator[_token, None, None]: ... +def get_parent_map(context: _SelectorContext) -> Dict[Element, Element]: ... +def prepare_child(next: _next, token: _token) -> _callback: ... +def prepare_star(next: _next, token: _token) -> _callback: ... +def prepare_self(next: _next, token: _token) -> _callback: ... +def prepare_descendant(next: _next, token: _token) -> _callback: ... +def prepare_parent(next: _next, token: _token) -> _callback: ... +def prepare_predicate(next: _next, token: _token) -> _callback: ... + +ops: Dict[str, Callable[[_next, _token], _callback]] + +class _SelectorContext: + parent_map: Dict[Element, Element] + root: Element + def __init__(self, root: Element) -> None: ... + +_T = TypeVar('_T') + +def iterfind(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ... +def find(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> Optional[Element]: ... +def findall(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ... +def findtext(elem: Element, path: str, default: Optional[_T] = ..., namespaces: Optional[Dict[str, str]] = ...) -> Union[_T, str]: ... diff --git a/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi new file mode 100644 index 000000000000..025b47493266 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi @@ -0,0 +1,259 @@ +# Stubs for xml.etree.ElementTree + +from typing import ( + Any, + Callable, + Dict, + Generator, + IO, + ItemsView, + Iterable, + Iterator, + KeysView, + List, + MutableSequence, + Optional, + Protocol, + Sequence, + Text, + Tuple, + TypeVar, + Union, + overload, +) +import io +import sys + +if sys.version_info < (3,) or sys.version_info >= (3, 8): + from typing import Literal +else: + from typing_extensions import Literal + +VERSION: str + +class ParseError(SyntaxError): + code: int + position: Tuple[int, int] + +def iselement(element: object) -> bool: ... + +_T = TypeVar('_T') + +# Type for parser inputs. Parser will accept any unicode/str/bytes and coerce, +# and this is true in py2 and py3 (even fromstringlist() in python3 can be +# called with a heterogeneous list) +_parser_input_type = Union[bytes, Text] + +# Type for individual tag/attr/ns/text values in args to most functions. +# In py2, the library accepts str or unicode everywhere and coerces +# aggressively. +# In py3, bytes is not coerced to str and so use of bytes is probably an error, +# so we exclude it. (why? the parser never produces bytes when it parses XML, +# so e.g., element.get(b'name') will always return None for parsed XML, even if +# there is a 'name' attribute.) +_str_argument_type = Union[str, Text] + +# Type for return values from individual tag/attr/text values +if sys.version_info >= (3,): + # note: in python3, everything comes out as str, yay: + _str_result_type = str +else: + # in python2, if the tag/attribute/text wasn't decode-able as ascii, it + # comes out as a unicode string; otherwise it comes out as str. (see + # _fixtext function in the source). Client code knows best: + _str_result_type = Any + +_file_or_filename = Union[str, bytes, int, IO[Any]] + +if sys.version_info >= (3, 8): + class _Writeable(Protocol): + def write(self, __s: str) -> Any: ... + + @overload + def canonicalize( + xml_data: Optional[_parser_input_type] = ..., + *, + out: None = ..., + from_file: Optional[_file_or_filename] = ..., + with_comments: bool = ..., + strip_text: bool = ..., + rewrite_prefixes: bool = ..., + qname_aware_tags: Optional[Iterable[str]] = ..., + qname_aware_attrs: Optional[Iterable[str]] = ..., + exclude_attrs: Optional[Iterable[str]] = ..., + exclude_tags: Optional[Iterable[str]] = ..., + ) -> str: ... + @overload + def canonicalize( + xml_data: Optional[_parser_input_type] = ..., + *, + out: _Writeable, + from_file: Optional[_file_or_filename] = ..., + with_comments: bool = ..., + strip_text: bool = ..., + rewrite_prefixes: bool = ..., + qname_aware_tags: Optional[Iterable[str]] = ..., + qname_aware_attrs: Optional[Iterable[str]] = ..., + exclude_attrs: Optional[Iterable[str]] = ..., + exclude_tags: Optional[Iterable[str]] = ..., + ) -> None: ... + +class Element(MutableSequence[Element]): + tag: _str_result_type + attrib: Dict[_str_result_type, _str_result_type] + text: Optional[_str_result_type] + tail: Optional[_str_result_type] + def __init__(self, tag: Union[_str_argument_type, Callable[..., Element]], attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type) -> None: ... + def append(self, subelement: Element) -> None: ... + def clear(self) -> None: ... + def copy(self) -> Element: ... + def extend(self, elements: Iterable[Element]) -> None: ... + def find(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[Element]: ... + def findall(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ... + @overload + def findtext(self, path: _str_argument_type, *, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[_str_result_type]: ... + @overload + def findtext(self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Union[_T, _str_result_type]: ... + @overload + def get(self, key: _str_argument_type) -> Optional[_str_result_type]: ... + @overload + def get(self, key: _str_argument_type, default: _T) -> Union[_str_result_type, _T]: ... + def getchildren(self) -> List[Element]: ... + def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ... + if sys.version_info >= (3, 2): + def insert(self, index: int, subelement: Element) -> None: ... + else: + def insert(self, index: int, element: Element) -> None: ... + def items(self) -> ItemsView[_str_result_type, _str_result_type]: ... + def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ... + def iterfind(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ... + def itertext(self) -> Generator[_str_result_type, None, None]: ... + def keys(self) -> KeysView[_str_result_type]: ... + def makeelement(self, tag: _str_argument_type, attrib: Dict[_str_argument_type, _str_argument_type]) -> Element: ... + def remove(self, subelement: Element) -> None: ... + def set(self, key: _str_argument_type, value: _str_argument_type) -> None: ... + def __bool__(self) -> bool: ... + def __delitem__(self, i: Union[int, slice]) -> None: ... + @overload + def __getitem__(self, i: int) -> Element: ... + @overload + def __getitem__(self, s: slice) -> MutableSequence[Element]: ... + def __len__(self) -> int: ... + @overload + def __setitem__(self, i: int, o: Element) -> None: ... + @overload + def __setitem__(self, s: slice, o: Iterable[Element]) -> None: ... + + +def SubElement(parent: Element, tag: _str_argument_type, attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type) -> Element: ... +def Comment(text: Optional[_str_argument_type] = ...) -> Element: ... +def ProcessingInstruction(target: _str_argument_type, text: Optional[_str_argument_type] = ...) -> Element: ... + +PI: Callable[..., Element] + +class QName: + text: str + def __init__(self, text_or_uri: _str_argument_type, tag: Optional[_str_argument_type] = ...) -> None: ... + +class ElementTree: + def __init__(self, element: Optional[Element] = ..., file: Optional[_file_or_filename] = ...) -> None: ... + def getroot(self) -> Element: ... + def parse(self, source: _file_or_filename, parser: Optional[XMLParser] = ...) -> Element: ... + def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ... + def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ... + def find(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[Element]: ... + @overload + def findtext(self, path: _str_argument_type, *, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[_str_result_type]: ... + @overload + def findtext(self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Union[_T, _str_result_type]: ... + def findall(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ... + def iterfind(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ... + if sys.version_info >= (3, 4): + def write(self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> None: ... + else: + def write(self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ...) -> None: ... + def write_c14n(self, file: _file_or_filename) -> None: ... + +def register_namespace(prefix: _str_argument_type, uri: _str_argument_type) -> None: ... +if sys.version_info >= (3,): + @overload + def tostring(element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> bytes: ... + @overload + def tostring(element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> str: ... + @overload + def tostring(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> Any: ... + @overload + def tostringlist(element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[bytes]: ... + @overload + def tostringlist(element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[str]: ... + @overload + def tostringlist(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[Any]: ... +else: + def tostring(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> bytes: ... + def tostringlist(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> List[bytes]: ... +def dump(elem: Element) -> None: ... +def parse(source: _file_or_filename, parser: Optional[XMLParser] = ...) -> ElementTree: ... +def iterparse(source: _file_or_filename, events: Optional[Sequence[str]] = ..., parser: Optional[XMLParser] = ...) -> Iterator[Tuple[str, Any]]: ... + +if sys.version_info >= (3, 4): + class XMLPullParser: + def __init__(self, events: Optional[Sequence[str]] = ..., *, _parser: Optional[XMLParser] = ...) -> None: ... + def feed(self, data: bytes) -> None: ... + def close(self) -> None: ... + def read_events(self) -> Iterator[Tuple[str, Element]]: ... + +def XML(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Element: ... +def XMLID(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Tuple[Element, Dict[_str_result_type, Element]]: ... + +# This is aliased to XML in the source. +fromstring = XML + +def fromstringlist(sequence: Sequence[_parser_input_type], parser: Optional[XMLParser] = ...) -> Element: ... + +# This type is both not precise enough and too precise. The TreeBuilder +# requires the elementfactory to accept tag and attrs in its args and produce +# some kind of object that has .text and .tail properties. +# I've chosen to constrain the ElementFactory to always produce an Element +# because that is how almost everyone will use it. +# Unfortunately, the type of the factory arguments is dependent on how +# TreeBuilder is called by client code (they could pass strs, bytes or whatever); +# but we don't want to use a too-broad type, or it would be too hard to write +# elementfactories. +_ElementFactory = Callable[[Any, Dict[Any, Any]], Element] + +class TreeBuilder: + def __init__(self, element_factory: Optional[_ElementFactory] = ...) -> None: ... + def close(self) -> Element: ... + def data(self, data: _parser_input_type) -> None: ... + def start(self, tag: _parser_input_type, attrs: Dict[_parser_input_type, _parser_input_type]) -> Element: ... + def end(self, tag: _parser_input_type) -> Element: ... + +if sys.version_info >= (3, 8): + class C14NWriterTarget: + def __init__( + self, + write: Callable[[str], Any], + *, + with_comments: bool = ..., + strip_text: bool = ..., + rewrite_prefixes: bool = ..., + qname_aware_tags: Optional[Iterable[str]] = ..., + qname_aware_attrs: Optional[Iterable[str]] = ..., + exclude_attrs: Optional[Iterable[str]] = ..., + exclude_tags: Optional[Iterable[str]] = ..., + ) -> None: ... + + +class XMLParser: + parser: Any + target: TreeBuilder + # TODO-what is entity used for??? + entity: Any + version: str + if sys.version_info >= (3, 8): + def __init__(self, *, target: Optional[TreeBuilder] = ..., encoding: Optional[str] = ...) -> None: ... + else: + def __init__(self, html: int = ..., target: Optional[TreeBuilder] = ..., encoding: Optional[str] = ...) -> None: ... + def doctype(self, name: str, pubid: str, system: str) -> None: ... + def close(self) -> Element: ... + def feed(self, data: _parser_input_type) -> None: ... diff --git a/python/helpers/typeshed/stdlib/2and3/xml/etree/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/xml/etree/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/python/helpers/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi b/python/helpers/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi new file mode 100644 index 000000000000..c384968d08ff --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi @@ -0,0 +1,3 @@ +# Stubs for xml.etree.cElementTree (Python 3.4) + +from xml.etree.ElementTree import * # noqa: F403 diff --git a/python/helpers/typeshed/stdlib/2and3/xml/parsers/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/xml/parsers/__init__.pyi new file mode 100644 index 000000000000..cac086235cba --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/parsers/__init__.pyi @@ -0,0 +1 @@ +import xml.parsers.expat as expat diff --git a/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi new file mode 100644 index 000000000000..73f3758c61ec --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi @@ -0,0 +1 @@ +from pyexpat import * diff --git a/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi new file mode 100644 index 000000000000..e22d769ec340 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi @@ -0,0 +1 @@ +from pyexpat.errors import * diff --git a/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi new file mode 100644 index 000000000000..d8f44b47c51b --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi @@ -0,0 +1 @@ +from pyexpat.model import * diff --git a/python/helpers/typeshed/stdlib/2and3/xml/sax/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/xml/sax/__init__.pyi new file mode 100644 index 000000000000..6edf12da86b4 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/sax/__init__.pyi @@ -0,0 +1,34 @@ +from typing import Any, List, NoReturn, Optional, Text, Union, IO + +import xml.sax +from xml.sax.xmlreader import InputSource, Locator +from xml.sax.handler import ContentHandler, ErrorHandler + +class SAXException(Exception): + def __init__(self, msg: str, exception: Optional[Exception] = ...) -> None: ... + def getMessage(self) -> str: ... + def getException(self) -> Exception: ... + def __getitem__(self, ix: Any) -> NoReturn: ... + +class SAXParseException(SAXException): + def __init__(self, msg: str, exception: Exception, locator: Locator) -> None: ... + def getColumnNumber(self) -> int: ... + def getLineNumber(self) -> int: ... + def getPublicId(self): ... + def getSystemId(self): ... + +class SAXNotRecognizedException(SAXException): ... +class SAXNotSupportedException(SAXException): ... +class SAXReaderNotAvailable(SAXNotSupportedException): ... + +default_parser_list: List[str] + +def make_parser(parser_list: List[str] = ...) -> xml.sax.xmlreader.XMLReader: ... + +def parse(source: Union[str, IO[str]], handler: xml.sax.handler.ContentHandler, + errorHandler: xml.sax.handler.ErrorHandler = ...) -> None: ... + +def parseString(string: Union[bytes, Text], handler: xml.sax.handler.ContentHandler, + errorHandler: Optional[xml.sax.handler.ErrorHandler] = ...) -> None: ... + +def _create_parser(parser_name: str) -> xml.sax.xmlreader.XMLReader: ... diff --git a/python/helpers/typeshed/stdlib/2and3/xml/sax/handler.pyi b/python/helpers/typeshed/stdlib/2and3/xml/sax/handler.pyi new file mode 100644 index 000000000000..3a5193300981 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/sax/handler.pyi @@ -0,0 +1,46 @@ +from typing import Any + +version: Any + +class ErrorHandler: + def error(self, exception): ... + def fatalError(self, exception): ... + def warning(self, exception): ... + +class ContentHandler: + def __init__(self) -> None: ... + def setDocumentLocator(self, locator): ... + def startDocument(self): ... + def endDocument(self): ... + def startPrefixMapping(self, prefix, uri): ... + def endPrefixMapping(self, prefix): ... + def startElement(self, name, attrs): ... + def endElement(self, name): ... + def startElementNS(self, name, qname, attrs): ... + def endElementNS(self, name, qname): ... + def characters(self, content): ... + def ignorableWhitespace(self, whitespace): ... + def processingInstruction(self, target, data): ... + def skippedEntity(self, name): ... + +class DTDHandler: + def notationDecl(self, name, publicId, systemId): ... + def unparsedEntityDecl(self, name, publicId, systemId, ndata): ... + +class EntityResolver: + def resolveEntity(self, publicId, systemId): ... + +feature_namespaces: Any +feature_namespace_prefixes: Any +feature_string_interning: Any +feature_validation: Any +feature_external_ges: Any +feature_external_pes: Any +all_features: Any +property_lexical_handler: Any +property_declaration_handler: Any +property_dom_node: Any +property_xml_string: Any +property_encoding: Any +property_interning_dict: Any +all_properties: Any diff --git a/python/helpers/typeshed/stdlib/2and3/xml/sax/saxutils.pyi b/python/helpers/typeshed/stdlib/2and3/xml/sax/saxutils.pyi new file mode 100644 index 000000000000..342d6ed84815 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/sax/saxutils.pyi @@ -0,0 +1,58 @@ +import sys +from typing import Mapping, Text + +from xml.sax import handler +from xml.sax import xmlreader + +def escape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... +def unescape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... +def quoteattr(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... + +class XMLGenerator(handler.ContentHandler): + if sys.version_info >= (3, 0): + def __init__(self, out=..., encoding=..., short_empty_elements: bool = ...) -> None: ... + else: + def __init__(self, out=..., encoding=...) -> None: ... + def startDocument(self): ... + def endDocument(self): ... + def startPrefixMapping(self, prefix, uri): ... + def endPrefixMapping(self, prefix): ... + def startElement(self, name, attrs): ... + def endElement(self, name): ... + def startElementNS(self, name, qname, attrs): ... + def endElementNS(self, name, qname): ... + def characters(self, content): ... + def ignorableWhitespace(self, content): ... + def processingInstruction(self, target, data): ... + +class XMLFilterBase(xmlreader.XMLReader): + def __init__(self, parent=...) -> None: ... + def error(self, exception): ... + def fatalError(self, exception): ... + def warning(self, exception): ... + def setDocumentLocator(self, locator): ... + def startDocument(self): ... + def endDocument(self): ... + def startPrefixMapping(self, prefix, uri): ... + def endPrefixMapping(self, prefix): ... + def startElement(self, name, attrs): ... + def endElement(self, name): ... + def startElementNS(self, name, qname, attrs): ... + def endElementNS(self, name, qname): ... + def characters(self, content): ... + def ignorableWhitespace(self, chars): ... + def processingInstruction(self, target, data): ... + def skippedEntity(self, name): ... + def notationDecl(self, name, publicId, systemId): ... + def unparsedEntityDecl(self, name, publicId, systemId, ndata): ... + def resolveEntity(self, publicId, systemId): ... + def parse(self, source): ... + def setLocale(self, locale): ... + def getFeature(self, name): ... + def setFeature(self, name, state): ... + def getProperty(self, name): ... + def setProperty(self, name, value): ... + def getParent(self): ... + def setParent(self, parent): ... + +def prepare_input_source(source, base=...): ... diff --git a/python/helpers/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi b/python/helpers/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi new file mode 100644 index 000000000000..fbc1ac1ef984 --- /dev/null +++ b/python/helpers/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi @@ -0,0 +1,71 @@ +class XMLReader: + def __init__(self) -> None: ... + def parse(self, source): ... + def getContentHandler(self): ... + def setContentHandler(self, handler): ... + def getDTDHandler(self): ... + def setDTDHandler(self, handler): ... + def getEntityResolver(self): ... + def setEntityResolver(self, resolver): ... + def getErrorHandler(self): ... + def setErrorHandler(self, handler): ... + def setLocale(self, locale): ... + def getFeature(self, name): ... + def setFeature(self, name, state): ... + def getProperty(self, name): ... + def setProperty(self, name, value): ... + +class IncrementalParser(XMLReader): + def __init__(self, bufsize=...) -> None: ... + def parse(self, source): ... + def feed(self, data): ... + def prepareParser(self, source): ... + def close(self): ... + def reset(self): ... + +class Locator: + def getColumnNumber(self): ... + def getLineNumber(self): ... + def getPublicId(self): ... + def getSystemId(self): ... + +class InputSource: + def __init__(self, system_id=...) -> None: ... + def setPublicId(self, public_id): ... + def getPublicId(self): ... + def setSystemId(self, system_id): ... + def getSystemId(self): ... + def setEncoding(self, encoding): ... + def getEncoding(self): ... + def setByteStream(self, bytefile): ... + def getByteStream(self): ... + def setCharacterStream(self, charfile): ... + def getCharacterStream(self): ... + +class AttributesImpl: + def __init__(self, attrs) -> None: ... + def getLength(self): ... + def getType(self, name): ... + def getValue(self, name): ... + def getValueByQName(self, name): ... + def getNameByQName(self, name): ... + def getQNameByName(self, name): ... + def getNames(self): ... + def getQNames(self): ... + def __len__(self): ... + def __getitem__(self, name): ... + def keys(self): ... + def has_key(self, name): ... + def __contains__(self, name): ... + def get(self, name, alternative=...): ... + def copy(self): ... + def items(self): ... + def values(self): ... + +class AttributesNSImpl(AttributesImpl): + def __init__(self, attrs, qnames) -> None: ... + def getValueByQName(self, name): ... + def getNameByQName(self, name): ... + def getQNameByName(self, name): ... + def getQNames(self): ... + def copy(self): ... diff --git a/python/tools/src/com/jetbrains/python/tools/PyTypeShedSync.kts b/python/tools/src/com/jetbrains/python/tools/PyTypeShedSync.kts index 61992d66c0b1..7df4d7fe8675 100644 --- a/python/tools/src/com/jetbrains/python/tools/PyTypeShedSync.kts +++ b/python/tools/src/com/jetbrains/python/tools/PyTypeShedSync.kts @@ -77,7 +77,8 @@ val whiteList = setOf( "unittest", "urllib", "uuid", - "werkzeug" + "werkzeug", + "xml" ) println("Cleaning")