stdlib: add argument default values (#9501)

stdlib/xml/dom/domreg.pyi

@@ -5,4 +5,6 @@ well_known_implementations: dict[str, str]
 registered: dict[str, Callable[[], DOMImplementation]]
 
 def registerDOMImplementation(name: str, factory: Callable[[], DOMImplementation]) -> None: ...
-def getDOMImplementation(name: str | None = ..., features: str | Iterable[tuple[str, str | None]] = ...) -> DOMImplementation: ...
+def getDOMImplementation(
+    name: str | None = None, features: str | Iterable[tuple[str, str | None]] = ...
+) -> DOMImplementation: ...

stdlib/xml/dom/expatbuilder.pyi

@@ -14,7 +14,7 @@ theDOMImplementation: DOMImplementation | None
 
 class ElementInfo:
     tagName: Incomplete
-    def __init__(self, tagName, model: Incomplete | None = ...) -> None: ...
+    def __init__(self, tagName, model: Incomplete | None = None) -> None: ...
     def getAttributeType(self, aname) -> TypeInfo: ...
     def getAttributeTypeNS(self, namespaceURI, localName) -> TypeInfo: ...
     def isElementContent(self) -> bool: ...
@@ -25,7 +25,7 @@ class ElementInfo:
 class ExpatBuilder:
     document: Document  # Created in self.reset()
     curNode: Incomplete  # Created in self.reset()
-    def __init__(self, options: Options | None = ...) -> None: ...
+    def __init__(self, options: Options | None = None) -> None: ...
     def createParser(self): ...
     def getParser(self): ...
     def reset(self) -> None: ...
@@ -71,7 +71,7 @@ class FragmentBuilder(ExpatBuilder):
     fragment: Incomplete | None
     originalDocument: Incomplete
     context: Incomplete
-    def __init__(self, context, options: Options | None = ...) -> None: ...
+    def __init__(self, context, options: Options | None = None) -> None: ...
 
 class Namespaces:
     def createParser(self): ...
@@ -93,8 +93,8 @@ class InternalSubsetExtractor(ExpatBuilder):
     def end_doctype_decl_handler(self) -> NoReturn: ...
     def start_element_handler(self, name, attrs) -> NoReturn: ...
 
-def parse(file: str | SupportsRead[ReadableBuffer | str], namespaces: bool = ...): ...
-def parseString(string: str | ReadableBuffer, namespaces: bool = ...): ...
-def parseFragment(file, context, namespaces: bool = ...): ...
-def parseFragmentString(string: str, context, namespaces: bool = ...): ...
+def parse(file: str | SupportsRead[ReadableBuffer | str], namespaces: bool = True): ...
+def parseString(string: str | ReadableBuffer, namespaces: bool = True): ...
+def parseFragment(file, context, namespaces: bool = True): ...
+def parseFragmentString(string: str, context, namespaces: bool = True): ...
 def makeBuilder(options: Options) -> ExpatBuilderNS | ExpatBuilder: ...

stdlib/xml/dom/minidom.pyi

@@ -5,9 +5,9 @@ from typing_extensions import Literal
 from xml.dom.xmlbuilder import DocumentLS, DOMImplementationLS
 from xml.sax.xmlreader import XMLReader
 
-def parse(file: str | SupportsRead[ReadableBuffer | str], parser: XMLReader | None = ..., bufsize: int | None = ...): ...
-def parseString(string: str | ReadableBuffer, parser: XMLReader | None = ...): ...
-def getDOMImplementation(features=...) -> DOMImplementation | None: ...
+def parse(file: str | SupportsRead[ReadableBuffer | str], parser: XMLReader | None = None, bufsize: int | None = None): ...
+def parseString(string: str | ReadableBuffer, parser: XMLReader | None = None): ...
+def getDOMImplementation(features=None) -> DOMImplementation | None: ...
 
 class Node(xml.dom.Node):
     namespaceURI: str | None
@@ -24,8 +24,10 @@ class Node(xml.dom.Node):
     def localName(self) -> str | None: ...
     def __bool__(self) -> Literal[True]: ...
     if sys.version_info >= (3, 9):
-        def toxml(self, encoding: str | None = ..., standalone: bool | None = ...): ...
-        def toprettyxml(self, indent: str = ..., newl: str = ..., encoding: str | None = ..., standalone: bool | None = ...): ...
+        def toxml(self, encoding: str | None = None, standalone: bool | None = None): ...
+        def toprettyxml(
+            self, indent: str = "\t", newl: str = "\n", encoding: str | None = None, standalone: bool | None = None
+        ): ...
     else:
         def toxml(self, encoding: str | None = ...): ...
         def toprettyxml(self, indent: str = ..., newl: str = ..., encoding: str | None = ...): ...
@@ -69,7 +71,7 @@ class Attr(Node):
     value: str
     prefix: Incomplete
     def __init__(
-        self, qName: str, namespaceURI: str | None = ..., localName: str | None = ..., prefix: Incomplete | None = ...
+        self, qName: str, namespaceURI: str | None = None, localName: str | None = None, prefix: Incomplete | None = None
     ) -> None: ...
     def unlink(self) -> None: ...
     @property
@@ -86,7 +88,7 @@ class NamedNodeMap:
     def keys(self): ...
     def keysNS(self): ...
     def values(self): ...
-    def get(self, name: str, value: Incomplete | None = ...): ...
+    def get(self, name: str, value: Incomplete | None = None): ...
     def __len__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
     def __ge__(self, other: NamedNodeMap) -> bool: ...
@@ -124,7 +126,7 @@ class Element(Node):
     childNodes: Incomplete
     nextSibling: Incomplete
     def __init__(
-        self, tagName, namespaceURI: str | None = ..., prefix: Incomplete | None = ..., localName: Incomplete | None = ...
+        self, tagName, namespaceURI: str | None = None, prefix: Incomplete | None = None, localName: Incomplete | None = None
     ) -> None: ...
     def unlink(self) -> None: ...
     def getAttribute(self, attname: str) -> str: ...
@@ -143,7 +145,7 @@ class Element(Node):
     def hasAttributeNS(self, namespaceURI: str, localName) -> bool: ...
     def getElementsByTagName(self, name: str): ...
     def getElementsByTagNameNS(self, namespaceURI: str, localName): ...
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
     def hasAttributes(self) -> bool: ...
     def setIdAttribute(self, name) -> None: ...
     def setIdAttributeNS(self, namespaceURI: str, localName) -> None: ...
@@ -170,7 +172,7 @@ class ProcessingInstruction(Childless, Node):
     def __init__(self, target, data) -> None: ...
     nodeValue: Incomplete
     nodeName: Incomplete
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class CharacterData(Childless, Node):
     ownerDocument: Incomplete
@@ -193,7 +195,7 @@ class Text(CharacterData):
     attributes: Incomplete
     data: Incomplete
     def splitText(self, offset): ...
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
     def replaceWholeText(self, content): ...
     @property
     def isWhitespaceInElementContent(self) -> bool: ...
@@ -204,12 +206,12 @@ class Comment(CharacterData):
     nodeType: int
     nodeName: str
     def __init__(self, data) -> None: ...
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class CDATASection(Text):
     nodeType: int
     nodeName: str
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class ReadOnlySequentialNamedNodeMap:
     def __init__(self, seq=...) -> None: ...
@@ -239,7 +241,7 @@ class DocumentType(Identified, Childless, Node):
     nodeName: Incomplete
     def __init__(self, qualifiedName: str) -> None: ...
     def cloneNode(self, deep): ...
-    def writexml(self, writer: SupportsWrite[str], indent: str = ..., addindent: str = ..., newl: str = ...) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class Entity(Identified, Node):
     attributes: Incomplete
@@ -321,11 +323,11 @@ class Document(Node, DocumentLS):
         def writexml(
             self,
             writer: SupportsWrite[str],
-            indent: str = ...,
-            addindent: str = ...,
-            newl: str = ...,
-            encoding: str | None = ...,
-            standalone: bool | None = ...,
+            indent: str = "",
+            addindent: str = "",
+            newl: str = "",
+            encoding: str | None = None,
+            standalone: bool | None = None,
         ) -> None: ...
     else:
         def writexml(

stdlib/xml/dom/pulldom.pyi

@@ -39,7 +39,7 @@ class PullDOM(ContentHandler):
     lastEvent: Incomplete
     elementStack: Sequence[Incomplete]
     pending_events: Sequence[Incomplete]
-    def __init__(self, documentFactory: _DocumentFactory = ...) -> None: ...
+    def __init__(self, documentFactory: _DocumentFactory = None) -> None: ...
     def pop(self) -> Element: ...
     def setDocumentLocator(self, locator) -> None: ...
     def startPrefixMapping(self, prefix, uri) -> None: ...
@@ -88,6 +88,6 @@ class SAX2DOM(PullDOM):
 default_bufsize: int
 
 def parse(
-    stream_or_string: str | SupportsRead[bytes] | SupportsRead[str], parser: XMLReader | None = ..., bufsize: int | None = ...
+    stream_or_string: str | SupportsRead[bytes] | SupportsRead[str], parser: XMLReader | None = None, bufsize: int | None = None
 ) -> DOMEventStream: ...
-def parseString(string: str, parser: XMLReader | None = ...) -> DOMEventStream: ...
+def parseString(string: str, parser: XMLReader | None = None) -> DOMEventStream: ...

stdlib/xml/etree/ElementInclude.pyi

@@ -12,14 +12,14 @@ if sys.version_info >= (3, 9):
 
 class FatalIncludeError(SyntaxError): ...
 
-def default_loader(href: FileDescriptorOrPath, parse: str, encoding: str | None = ...) -> str | Element: ...
+def default_loader(href: FileDescriptorOrPath, parse: str, encoding: str | None = None) -> 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...
 if sys.version_info >= (3, 9):
     def include(
-        elem: Element, loader: Callable[..., str | Element] | None = ..., base_url: str | None = ..., max_depth: int | None = ...
+        elem: Element, loader: Callable[..., str | Element] | None = None, base_url: str | None = None, max_depth: int | None = 6
     ) -> None: ...
 
     class LimitedRecursiveIncludeError(FatalIncludeError): ...

stdlib/xml/etree/ElementPath.pyi

@@ -10,7 +10,7 @@ _Token: TypeAlias = tuple[str, str]
 _Next: TypeAlias = Callable[[], _Token]
 _Callback: TypeAlias = Callable[[_SelectorContext, list[Element]], Generator[Element, None, None]]
 
-def xpath_tokenizer(pattern: str, namespaces: dict[str, str] | None = ...) -> Generator[_Token, None, None]: ...
+def xpath_tokenizer(pattern: str, namespaces: dict[str, str] | None = None) -> 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: ...
@@ -28,7 +28,7 @@ class _SelectorContext:
 
 _T = TypeVar("_T")
 
-def iterfind(elem: Element, path: str, namespaces: dict[str, str] | None = ...) -> Generator[Element, None, None]: ...
-def find(elem: Element, path: str, namespaces: dict[str, str] | None = ...) -> Element | None: ...
-def findall(elem: Element, path: str, namespaces: dict[str, str] | None = ...) -> list[Element]: ...
-def findtext(elem: Element, path: str, default: _T | None = ..., namespaces: dict[str, str] | None = ...) -> _T | str: ...
+def iterfind(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
+def find(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+def findall(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+def findtext(elem: Element, path: str, default: _T | None = None, namespaces: dict[str, str] | None = None) -> _T | str: ...

stdlib/xml/etree/ElementTree.pyi

@@ -90,8 +90,8 @@ class Element:
     def append(self, __subelement: Element) -> None: ...
     def clear(self) -> None: ...
     def extend(self, __elements: Iterable[Element]) -> None: ...
-    def find(self, path: str, namespaces: dict[str, str] | None = ...) -> Element | None: ...
-    def findall(self, path: str, namespaces: dict[str, str] | None = ...) -> list[Element]: ...
+    def find(self, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+    def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
     @overload
     def findtext(self, path: str, default: None = ..., namespaces: dict[str, str] | None = ...) -> str | None: ...
     @overload
@@ -102,8 +102,8 @@ class Element:
     def get(self, key: str, default: _T) -> str | _T: ...
     def insert(self, __index: int, __subelement: Element) -> None: ...
     def items(self) -> ItemsView[str, str]: ...
-    def iter(self, tag: str | None = ...) -> Generator[Element, None, None]: ...
-    def iterfind(self, path: str, namespaces: dict[str, str] | None = ...) -> Generator[Element, None, None]: ...
+    def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
+    def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
     def itertext(self) -> Generator[str, None, None]: ...
     def keys(self) -> dict_keys[str, str]: ...
     # makeelement returns the type of self in Python impl, but not in C impl
@@ -129,14 +129,14 @@ class Element:
         def getiterator(self, tag: str | None = ...) -> list[Element]: ...
 
 def SubElement(parent: Element, tag: str, attrib: dict[str, str] = ..., **extra: str) -> Element: ...
-def Comment(text: str | None = ...) -> Element: ...
-def ProcessingInstruction(target: str, text: str | None = ...) -> Element: ...
+def Comment(text: str | None = None) -> Element: ...
+def ProcessingInstruction(target: str, text: str | None = None) -> Element: ...
 
 PI: Callable[..., Element]
 
 class QName:
     text: str
-    def __init__(self, text_or_uri: str, tag: str | None = ...) -> None: ...
+    def __init__(self, text_or_uri: str, tag: str | None = None) -> None: ...
     def __lt__(self, other: QName | str) -> bool: ...
     def __le__(self, other: QName | str) -> bool: ...
     def __gt__(self, other: QName | str) -> bool: ...
@@ -144,29 +144,29 @@ class QName:
     def __eq__(self, other: object) -> bool: ...
 
 class ElementTree:
-    def __init__(self, element: Element | None = ..., file: _FileRead | None = ...) -> None: ...
+    def __init__(self, element: Element | None = None, file: _FileRead | None = None) -> None: ...
     def getroot(self) -> Element | Any: ...
-    def parse(self, source: _FileRead, parser: XMLParser | None = ...) -> Element: ...
-    def iter(self, tag: str | None = ...) -> Generator[Element, None, None]: ...
+    def parse(self, source: _FileRead, parser: XMLParser | None = None) -> Element: ...
+    def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
     if sys.version_info < (3, 9):
         def getiterator(self, tag: str | None = ...) -> list[Element]: ...
 
-    def find(self, path: str, namespaces: dict[str, str] | None = ...) -> Element | None: ...
+    def find(self, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
     @overload
     def findtext(self, path: str, default: None = ..., namespaces: dict[str, str] | None = ...) -> str | None: ...
     @overload
     def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = ...) -> _T | str: ...
-    def findall(self, path: str, namespaces: dict[str, str] | None = ...) -> list[Element]: ...
-    def iterfind(self, path: str, namespaces: dict[str, str] | None = ...) -> Generator[Element, None, None]: ...
+    def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+    def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
     def write(
         self,
         file_or_filename: _FileWrite,
-        encoding: str | None = ...,
-        xml_declaration: bool | None = ...,
-        default_namespace: str | None = ...,
-        method: str | None = ...,
+        encoding: str | None = None,
+        xml_declaration: bool | None = None,
+        default_namespace: str | None = None,
+        method: str | None = None,
         *,
-        short_empty_elements: bool = ...,
+        short_empty_elements: bool = True,
     ) -> None: ...
     def write_c14n(self, file: _FileWriteC14N) -> None: ...
 
@@ -261,28 +261,28 @@ else:
 def dump(elem: Element) -> None: ...
 
 if sys.version_info >= (3, 9):
-    def indent(tree: Element | ElementTree, space: str = ..., level: int = ...) -> None: ...
+    def indent(tree: Element | ElementTree, space: str = "  ", level: int = 0) -> None: ...
 
-def parse(source: _FileRead, parser: XMLParser | None = ...) -> ElementTree: ...
+def parse(source: _FileRead, parser: XMLParser | None = None) -> ElementTree: ...
 def iterparse(
-    source: _FileRead, events: Sequence[str] | None = ..., parser: XMLParser | None = ...
+    source: _FileRead, events: Sequence[str] | None = None, parser: XMLParser | None = None
 ) -> Iterator[tuple[str, Any]]: ...
 
 class XMLPullParser:
-    def __init__(self, events: Sequence[str] | None = ..., *, _parser: XMLParser | None = ...) -> None: ...
+    def __init__(self, events: Sequence[str] | None = None, *, _parser: XMLParser | None = None) -> None: ...
     def feed(self, data: str | ReadableBuffer) -> None: ...
     def close(self) -> None: ...
     # Second element in the tuple could be `Element`, `tuple[str, str]` or `None`.
     # Use `Any` to avoid false-positive errors.
     def read_events(self) -> Iterator[tuple[str, Any]]: ...
 
-def XML(text: str | ReadableBuffer, parser: XMLParser | None = ...) -> Element: ...
-def XMLID(text: str | ReadableBuffer, parser: XMLParser | None = ...) -> tuple[Element, dict[str, Element]]: ...
+def XML(text: str | ReadableBuffer, parser: XMLParser | None = None) -> Element: ...
+def XMLID(text: str | ReadableBuffer, parser: XMLParser | None = None) -> tuple[Element, dict[str, Element]]: ...
 
 # This is aliased to XML in the source.
 fromstring = XML
 
-def fromstringlist(sequence: Sequence[str | ReadableBuffer], parser: XMLParser | None = ...) -> Element: ...
+def fromstringlist(sequence: Sequence[str | ReadableBuffer], parser: XMLParser | None = None) -> 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
@@ -329,13 +329,13 @@ if sys.version_info >= (3, 8):
             self,
             write: Callable[[str], object],
             *,
-            with_comments: bool = ...,
-            strip_text: bool = ...,
-            rewrite_prefixes: bool = ...,
-            qname_aware_tags: Iterable[str] | None = ...,
-            qname_aware_attrs: Iterable[str] | None = ...,
-            exclude_attrs: Iterable[str] | None = ...,
-            exclude_tags: Iterable[str] | None = ...,
+            with_comments: bool = False,
+            strip_text: bool = False,
+            rewrite_prefixes: bool = False,
+            qname_aware_tags: Iterable[str] | None = None,
+            qname_aware_attrs: Iterable[str] | None = None,
+            exclude_attrs: Iterable[str] | None = None,
+            exclude_tags: Iterable[str] | None = None,
         ) -> None: ...
         def data(self, data: str) -> None: ...
         def start_ns(self, prefix: str, uri: str) -> None: ...

stdlib/xml/sax/__init__.pyi

@@ -9,7 +9,7 @@ class _SupportsReadClose(SupportsRead[_T_co], Protocol[_T_co]):
     def close(self) -> None: ...
 
 class SAXException(Exception):
-    def __init__(self, msg: str, exception: Exception | None = ...) -> None: ...
+    def __init__(self, msg: str, exception: Exception | None = None) -> None: ...
     def getMessage(self) -> str: ...
     def getException(self) -> Exception: ...
     def __getitem__(self, ix: Any) -> NoReturn: ...

stdlib/xml/sax/saxutils.pyi

@@ -11,9 +11,9 @@ def quoteattr(data: str, entities: Mapping[str, str] = ...) -> str: ...
 class XMLGenerator(handler.ContentHandler):
     def __init__(
         self,
-        out: TextIOBase | RawIOBase | StreamWriter | StreamReaderWriter | SupportsWrite[str] | None = ...,
-        encoding: str = ...,
-        short_empty_elements: bool = ...,
+        out: TextIOBase | RawIOBase | StreamWriter | StreamReaderWriter | SupportsWrite[str] | None = None,
+        encoding: str = "iso-8859-1",
+        short_empty_elements: bool = False,
     ) -> None: ...
     def startDocument(self): ...
     def endDocument(self): ...
@@ -28,7 +28,7 @@ class XMLGenerator(handler.ContentHandler):
     def processingInstruction(self, target, data): ...
 
 class XMLFilterBase(xmlreader.XMLReader):
-    def __init__(self, parent: xmlreader.XMLReader | None = ...) -> None: ...
+    def __init__(self, parent: xmlreader.XMLReader | None = None) -> None: ...
     def error(self, exception): ...
     def fatalError(self, exception): ...
     def warning(self, exception): ...
@@ -57,4 +57,4 @@ class XMLFilterBase(xmlreader.XMLReader):
     def getParent(self): ...
     def setParent(self, parent): ...
 
-def prepare_input_source(source, base=...): ...
+def prepare_input_source(source, base=""): ...

stdlib/xml/sax/xmlreader.pyi

@@ -17,7 +17,7 @@ class XMLReader:
     def setProperty(self, name, value): ...
 
 class IncrementalParser(XMLReader):
-    def __init__(self, bufsize: int = ...) -> None: ...
+    def __init__(self, bufsize: int = 65536) -> None: ...
     def parse(self, source): ...
     def feed(self, data): ...
     def prepareParser(self, source): ...
@@ -31,7 +31,7 @@ class Locator:
     def getSystemId(self): ...
 
 class InputSource:
-    def __init__(self, system_id: str | None = ...) -> None: ...
+    def __init__(self, system_id: str | None = None) -> None: ...
     def setPublicId(self, public_id): ...
     def getPublicId(self): ...
     def setSystemId(self, system_id): ...
@@ -57,7 +57,7 @@ class AttributesImpl:
     def __getitem__(self, name): ...
     def keys(self): ...
     def __contains__(self, name): ...
-    def get(self, name, alternative=...): ...
+    def get(self, name, alternative=None): ...
     def copy(self): ...
     def items(self): ...
     def values(self): ...