basedpyright 1.36.2 → 1.37.0-961d59bacff1958014fe4e9ed2ef3116fe2266e2

package/dist/typeshed-fallback/stubs/html5lib/html5lib/_inputstream.pyi

@@ -1,37 +1,36 @@
-from _typeshed import Incomplete, SupportsRead
-from codecs import CodecInfo
-from typing import Protocol, overload, type_check_only
-from typing_extensions import TypeAlias
+import re
+from _io import BytesIO, StringIO
+from _typeshed import Incomplete, ReadableBuffer, SupportsRead
+from collections.abc import Callable, Iterable
+from typing import Any, AnyStr, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
-# Is actually webencodings.Encoding
-@type_check_only
-class _Encoding(Protocol):
-    name: str
-    codec_info: CodecInfo
-    def __init__(self, name: str, codec_info: CodecInfo) -> None: ...
+from webencodings import Encoding
 
 _UnicodeInputStream: TypeAlias = str | SupportsRead[str]
 _BinaryInputStream: TypeAlias = bytes | SupportsRead[bytes]
 _InputStream: TypeAlias = _UnicodeInputStream | _BinaryInputStream  # noqa: Y047  # used in other files
+_SupportsReadT = TypeVar("_SupportsReadT", bound=SupportsRead[Any])
+_SupportsReadBytesT = TypeVar("_SupportsReadBytesT", bound=SupportsRead[bytes])
 
-spaceCharactersBytes: Incomplete
-asciiLettersBytes: Incomplete
-asciiUppercaseBytes: Incomplete
-spacesAngleBrackets: Incomplete
+spaceCharactersBytes: frozenset[bytes]
+asciiLettersBytes: frozenset[bytes]
+asciiUppercaseBytes: frozenset[bytes]
+spacesAngleBrackets: frozenset[bytes]
 invalid_unicode_no_surrogate: str
-invalid_unicode_re: Incomplete
-non_bmp_invalid_codepoints: Incomplete
-ascii_punctuation_re: Incomplete
-charsUntilRegEx: Incomplete
+invalid_unicode_re: re.Pattern[str]
+non_bmp_invalid_codepoints: set[int]
+ascii_punctuation_re: re.Pattern[str]
+charsUntilRegEx: dict[tuple[Iterable[str | bytes | bytearray], bool], re.Pattern[str]]
 
-class BufferedStream:
-    stream: Incomplete
-    buffer: Incomplete
-    position: Incomplete
-    def __init__(self, stream) -> None: ...
-    def tell(self): ...
-    def seek(self, pos) -> None: ...
-    def read(self, bytes): ...
+class BufferedStream(Generic[AnyStr]):
+    stream: SupportsRead[AnyStr]
+    buffer: list[AnyStr]
+    position: list[int]
+    def __init__(self, stream: SupportsRead[AnyStr]) -> None: ...
+    def tell(self) -> int: ...
+    def seek(self, pos: int) -> None: ...
+    def read(self, bytes: int) -> AnyStr: ...
 
 @overload
 def HTMLInputStream(source: _UnicodeInputStream) -> HTMLUnicodeInputStream: ...
@@ -48,9 +47,9 @@ def HTMLInputStream(
 ) -> HTMLBinaryInputStream: ...
 
 class HTMLUnicodeInputStream:
-    reportCharacterErrors: Incomplete
-    newLines: Incomplete
-    charEncoding: tuple[_Encoding, str]
+    reportCharacterErrors: Callable[[str], None]
+    newLines: list[int]
+    charEncoding: tuple[Encoding, str]
     dataStream: Incomplete
     def __init__(self, source: _UnicodeInputStream) -> None: ...
     chunk: str
@@ -60,14 +59,17 @@ class HTMLUnicodeInputStream:
     prevNumLines: int
     prevNumCols: int
     def reset(self) -> None: ...
-    def openStream(self, source): ...
+    @overload
+    def openStream(self, source: _SupportsReadT) -> _SupportsReadT: ...
+    @overload
+    def openStream(self, source: str | None) -> StringIO: ...
     def position(self) -> tuple[int, int]: ...
-    def char(self): ...
-    def readChunk(self, chunkSize=None): ...
-    def characterErrorsUCS4(self, data) -> None: ...
-    def characterErrorsUCS2(self, data) -> None: ...
-    def charsUntil(self, characters, opposite: bool = False): ...
-    def unget(self, char) -> None: ...
+    def char(self) -> str | None: ...
+    def readChunk(self, chunkSize: int | None = None) -> bool: ...
+    def characterErrorsUCS4(self, data: str) -> None: ...
+    def characterErrorsUCS2(self, data: str) -> None: ...
+    def charsUntil(self, characters: Iterable[str | bytes | bytearray], opposite: bool = False) -> str: ...
+    def unget(self, char: str | None) -> None: ...
 
 class HTMLBinaryInputStream(HTMLUnicodeInputStream):
     rawStream: Incomplete
@@ -77,8 +79,8 @@ class HTMLBinaryInputStream(HTMLUnicodeInputStream):
     transport_encoding: Incomplete
     same_origin_parent_encoding: Incomplete
     likely_encoding: Incomplete
-    default_encoding: Incomplete
-    charEncoding: tuple[_Encoding, str]
+    default_encoding: str
+    charEncoding: tuple[Encoding, str]
     def __init__(
         self,
         source: _BinaryInputStream,
@@ -91,46 +93,52 @@ class HTMLBinaryInputStream(HTMLUnicodeInputStream):
     ) -> None: ...
     dataStream: Incomplete
     def reset(self) -> None: ...
-    def openStream(self, source): ...
+    @overload  # type: ignore[override]
+    def openStream(self, source: _SupportsReadBytesT) -> _SupportsReadBytesT: ...
+    @overload  # type: ignore[override]
+    def openStream(self, source: ReadableBuffer) -> BytesIO: ...
     def determineEncoding(self, chardet: bool = True): ...
     def changeEncoding(self, newEncoding: str | bytes | None) -> None: ...
-    def detectBOM(self): ...
-    def detectEncodingMeta(self): ...
+    def detectBOM(self) -> Encoding | None: ...
+    def detectEncodingMeta(self) -> Encoding | None: ...
 
 class EncodingBytes(bytes):
-    def __new__(self, value): ...
-    def __init__(self, value) -> None: ...
-    def __iter__(self): ...
-    def __next__(self): ...
-    def next(self): ...
-    def previous(self): ...
-    def setPosition(self, position) -> None: ...
-    def getPosition(self): ...
-    position: Incomplete
-    def getCurrentByte(self): ...
+    def __new__(self, value: bytes) -> Self: ...
+    def __init__(self, value: bytes) -> None: ...
+    def __iter__(self) -> Self: ...  # type: ignore[override]
+    def __next__(self) -> bytes: ...
+    def next(self) -> bytes: ...
+    def previous(self) -> bytes: ...
+    def setPosition(self, position: int) -> None: ...
+    def getPosition(self) -> int | None: ...
     @property
-    def currentByte(self): ...
-    def skip(self, chars=...): ...
-    def skipUntil(self, chars): ...
-    def matchBytes(self, bytes): ...
-    def jumpTo(self, bytes): ...
+    def position(self) -> int | None: ...
+    @position.setter
+    def position(self, position: int) -> None: ...
+    def getCurrentByte(self) -> bytes: ...
+    @property
+    def currentByte(self) -> bytes: ...
+    def skip(self, chars: bytes | bytearray | Iterable[bytes] = ...) -> bytes | None: ...
+    def skipUntil(self, chars: bytes | bytearray | Iterable[bytes]) -> bytes | None: ...
+    def matchBytes(self, bytes: bytes | bytearray) -> bool: ...
+    def jumpTo(self, bytes: bytes | bytearray) -> Literal[True]: ...
 
 class EncodingParser:
-    data: Incomplete
-    encoding: Incomplete
-    def __init__(self, data) -> None: ...
-    def getEncoding(self): ...
-    def handleComment(self): ...
-    def handleMeta(self): ...
-    def handlePossibleStartTag(self): ...
-    def handlePossibleEndTag(self): ...
-    def handlePossibleTag(self, endTag): ...
-    def handleOther(self): ...
-    def getAttribute(self): ...
+    data: EncodingBytes
+    encoding: Encoding | None
+    def __init__(self, data: bytes) -> None: ...
+    def getEncoding(self) -> Encoding | None: ...
+    def handleComment(self) -> bool: ...
+    def handleMeta(self) -> bool: ...
+    def handlePossibleStartTag(self) -> bool: ...
+    def handlePossibleEndTag(self) -> bool: ...
+    def handlePossibleTag(self, endTag: bool | None) -> bool: ...
+    def handleOther(self) -> bool: ...
+    def getAttribute(self) -> tuple[bytes, bytes] | None: ...
 
 class ContentAttrParser:
-    data: Incomplete
-    def __init__(self, data) -> None: ...
-    def parse(self): ...
+    data: EncodingBytes
+    def __init__(self, data: EncodingBytes) -> None: ...
+    def parse(self) -> bytes | None: ...
 
-def lookupEncoding(encoding: str | bytes | None) -> str | None: ...
+def lookupEncoding(encoding: str | bytes | None) -> Encoding | None: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/_tokenizer.pyi

@@ -1,42 +1,78 @@
 from _typeshed import Incomplete
+from collections import deque
+from collections.abc import Callable, Iterator
+from typing import TypedDict, overload, type_check_only
 
-from ._inputstream import _InputStream
+from ._inputstream import HTMLBinaryInputStream, HTMLUnicodeInputStream, _BinaryInputStream, _UnicodeInputStream
+from ._trie import Trie
 
-entitiesTrie: Incomplete
+@type_check_only
+class _DataVars(TypedDict, total=False):
+    data: str | None
+    charAsInt: int
+
+@type_check_only
+class _Token(TypedDict, total=False):
+    type: int
+    data: str | list[str]
+    datavars: _DataVars
+    name: str
+    selfClosing: bool
+    selfClosingAcknowledged: bool
+    publicId: str | None
+    systemId: str | None
+    correct: bool
+
+entitiesTrie: Trie
 attributeMap = dict
 
 class HTMLTokenizer:
-    stream: Incomplete
+    # TODO: Use Protocol to allow subclasses to set `stream` that do not inherit from HTMLUnicodeInputStream
+    stream: HTMLUnicodeInputStream | HTMLBinaryInputStream
     parser: Incomplete
     escapeFlag: bool
-    lastFourChars: Incomplete
-    state: Incomplete
+    lastFourChars: list[Incomplete]
+    state: Callable[[], bool]
     escape: bool
-    currentToken: Incomplete
-    def __init__(self, stream: _InputStream, parser=None, **kwargs) -> None: ...
-    tokenQueue: Incomplete
-    def __iter__(self): ...
-    def consumeNumberEntity(self, isHex): ...
-    def consumeEntity(self, allowedChar=None, fromAttribute: bool = False) -> None: ...
-    def processEntityInAttribute(self, allowedChar) -> None: ...
+    currentToken: _Token | None
+    @overload
+    def __init__(self, stream: _UnicodeInputStream, parser=None) -> None: ...
+    @overload
+    def __init__(
+        self,
+        stream: _BinaryInputStream,
+        parser=None,
+        *,
+        override_encoding: str | bytes | None = None,
+        transport_encoding: str | bytes | None = None,
+        same_origin_parent_encoding: str | bytes | None = None,
+        likely_encoding: str | bytes | None = None,
+        default_encoding: str = "windows-1252",
+        useChardet: bool = True,
+    ) -> None: ...
+    tokenQueue: deque[_Token]
+    def __iter__(self) -> Iterator[_Token]: ...
+    def consumeNumberEntity(self, isHex: bool | None) -> str: ...
+    def consumeEntity(self, allowedChar: str | None = None, fromAttribute: bool = False) -> None: ...
+    def processEntityInAttribute(self, allowedChar: str | None) -> None: ...
     def emitCurrentToken(self) -> None: ...
-    def dataState(self): ...
-    def entityDataState(self): ...
-    def rcdataState(self): ...
-    def characterReferenceInRcdata(self): ...
-    def rawtextState(self): ...
-    def scriptDataState(self): ...
-    def plaintextState(self): ...
-    def tagOpenState(self): ...
-    def closeTagOpenState(self): ...
-    def tagNameState(self): ...
+    def dataState(self) -> bool: ...
+    def entityDataState(self) -> bool: ...
+    def rcdataState(self) -> bool: ...
+    def characterReferenceInRcdata(self) -> bool: ...
+    def rawtextState(self) -> bool: ...
+    def scriptDataState(self) -> bool: ...
+    def plaintextState(self) -> bool: ...
+    def tagOpenState(self) -> bool: ...
+    def closeTagOpenState(self) -> bool: ...
+    def tagNameState(self) -> bool: ...
     temporaryBuffer: str
-    def rcdataLessThanSignState(self): ...
-    def rcdataEndTagOpenState(self): ...
-    def rcdataEndTagNameState(self): ...
-    def rawtextLessThanSignState(self): ...
-    def rawtextEndTagOpenState(self): ...
-    def rawtextEndTagNameState(self): ...
+    def rcdataLessThanSignState(self) -> bool: ...
+    def rcdataEndTagOpenState(self) -> bool: ...
+    def rcdataEndTagNameState(self) -> bool: ...
+    def rawtextLessThanSignState(self) -> bool: ...
+    def rawtextEndTagOpenState(self) -> bool: ...
+    def rawtextEndTagNameState(self) -> bool: ...
     def scriptDataLessThanSignState(self) -> bool: ...
     def scriptDataEndTagOpenState(self) -> bool: ...
     def scriptDataEndTagNameState(self) -> bool: ...
@@ -54,17 +90,17 @@ class HTMLTokenizer:
     def scriptDataDoubleEscapedDashDashState(self) -> bool: ...
     def scriptDataDoubleEscapedLessThanSignState(self) -> bool: ...
     def scriptDataDoubleEscapeEndState(self) -> bool: ...
-    def beforeAttributeNameState(self): ...
-    def attributeNameState(self): ...
-    def afterAttributeNameState(self): ...
-    def beforeAttributeValueState(self): ...
-    def attributeValueDoubleQuotedState(self): ...
-    def attributeValueSingleQuotedState(self): ...
-    def attributeValueUnQuotedState(self): ...
-    def afterAttributeValueState(self): ...
-    def selfClosingStartTagState(self): ...
-    def bogusCommentState(self): ...
-    def markupDeclarationOpenState(self): ...
+    def beforeAttributeNameState(self) -> bool: ...
+    def attributeNameState(self) -> bool: ...
+    def afterAttributeNameState(self) -> bool: ...
+    def beforeAttributeValueState(self) -> bool: ...
+    def attributeValueDoubleQuotedState(self) -> bool: ...
+    def attributeValueSingleQuotedState(self) -> bool: ...
+    def attributeValueUnQuotedState(self) -> bool: ...
+    def afterAttributeValueState(self) -> bool: ...
+    def selfClosingStartTagState(self) -> bool: ...
+    def bogusCommentState(self) -> bool: ...
+    def markupDeclarationOpenState(self) -> bool: ...
     def commentStartState(self) -> bool: ...
     def commentStartDashState(self) -> bool: ...
     def commentState(self) -> bool: ...
@@ -76,15 +112,15 @@ class HTMLTokenizer:
     def doctypeNameState(self) -> bool: ...
     def afterDoctypeNameState(self) -> bool: ...
     def afterDoctypePublicKeywordState(self) -> bool: ...
-    def beforeDoctypePublicIdentifierState(self): ...
-    def doctypePublicIdentifierDoubleQuotedState(self): ...
-    def doctypePublicIdentifierSingleQuotedState(self): ...
-    def afterDoctypePublicIdentifierState(self): ...
-    def betweenDoctypePublicAndSystemIdentifiersState(self): ...
-    def afterDoctypeSystemKeywordState(self): ...
-    def beforeDoctypeSystemIdentifierState(self): ...
-    def doctypeSystemIdentifierDoubleQuotedState(self): ...
-    def doctypeSystemIdentifierSingleQuotedState(self): ...
-    def afterDoctypeSystemIdentifierState(self): ...
-    def bogusDoctypeState(self): ...
-    def cdataSectionState(self): ...
+    def beforeDoctypePublicIdentifierState(self) -> bool: ...
+    def doctypePublicIdentifierDoubleQuotedState(self) -> bool: ...
+    def doctypePublicIdentifierSingleQuotedState(self) -> bool: ...
+    def afterDoctypePublicIdentifierState(self) -> bool: ...
+    def betweenDoctypePublicAndSystemIdentifiersState(self) -> bool: ...
+    def afterDoctypeSystemKeywordState(self) -> bool: ...
+    def beforeDoctypeSystemIdentifierState(self) -> bool: ...
+    def doctypeSystemIdentifierDoubleQuotedState(self) -> bool: ...
+    def doctypeSystemIdentifierSingleQuotedState(self) -> bool: ...
+    def afterDoctypeSystemIdentifierState(self) -> bool: ...
+    def bogusDoctypeState(self) -> bool: ...
+    def cdataSectionState(self) -> bool: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/_utils.pyi

@@ -1,6 +1,7 @@
 import xml.etree.ElementTree as default_etree
-from _typeshed import Incomplete
-from collections.abc import Mapping
+from _typeshed import Incomplete, Unused
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Final, TypeVar, overload
 
 __all__ = [
     "default_etree",
@@ -11,13 +12,19 @@ __all__ = [
     "supports_lone_surrogates",
 ]
 
-supports_lone_surrogates: bool
+supports_lone_surrogates: Final[bool]
 
-class MethodDispatcher(dict[Incomplete, Incomplete]):
-    default: Incomplete
-    def __init__(self, items=()) -> None: ...
-    def __getitem__(self, key): ...
-    def __get__(self, instance, owner=None): ...
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+class MethodDispatcher(dict[_K, _V]):
+    default: _V | None
+    @overload  # to solve `reportInvalidTypeVarUse`
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, items: Iterable[tuple[_K | Iterable[_K], _V]]) -> None: ...
+    def __getitem__(self, key: _K) -> _V | None: ...  # type: ignore[override]
+    def __get__(self, instance, owner: Unused = None) -> BoundMethodDispatcher: ...
 
 class BoundMethodDispatcher(Mapping[Incomplete, Incomplete]):
     instance: Incomplete
@@ -27,8 +34,8 @@ class BoundMethodDispatcher(Mapping[Incomplete, Incomplete]):
     def get(self, key, default): ...  # type: ignore[override]
     def __iter__(self): ...
     def __len__(self) -> int: ...
-    def __contains__(self, key): ...
+    def __contains__(self, key) -> bool: ...
 
-def isSurrogatePair(data): ...
-def surrogatePairToCodepoint(data): ...
+def isSurrogatePair(data: Sequence[str | bytes | bytearray]) -> bool: ...
+def surrogatePairToCodepoint(data: Sequence[str | bytes | bytearray]) -> int: ...
 def moduleFactoryFactory(factory): ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/constants.pyi

@@ -1,6 +1,4 @@
-from _typeshed import Incomplete
-
-EOF: Incomplete
+EOF: None
 E: dict[str, str]
 namespaces: dict[str, str]
 scopingElements: frozenset[tuple[str, str]]

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/alphabeticalattributes.pyi

@@ -1,4 +1,5 @@
+from _typeshed import Incomplete
+
 from . import base
 
-class Filter(base.Filter):
-    def __iter__(self): ...
+class Filter(base.Filter[dict[str, Incomplete]]): ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/base.pyi

@@ -1,7 +1,10 @@
-from _typeshed import Incomplete
+from collections.abc import Iterable, Iterator
+from typing import Any, Generic, TypeVar
 
-class Filter:
-    source: Incomplete
-    def __init__(self, source) -> None: ...
-    def __iter__(self): ...
-    def __getattr__(self, name: str): ...
+_T = TypeVar("_T", default=Any)
+
+class Filter(Generic[_T]):
+    source: Iterable[_T]
+    def __init__(self, source: Iterable[_T]) -> None: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __getattr__(self, name: str) -> Any: ...  # Depends on `source`

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/inject_meta_charset.pyi

@@ -1,6 +1,8 @@
+from _typeshed import Incomplete
+from collections.abc import Iterable
+
 from . import base
 
-class Filter(base.Filter):
+class Filter(base.Filter[dict[str, Incomplete]]):
     encoding: str | None
-    def __init__(self, source, encoding: str | None) -> None: ...
-    def __iter__(self): ...
+    def __init__(self, source: Iterable[dict[str, Incomplete]], encoding: str | None) -> None: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/lint.pyi

@@ -1,8 +1,10 @@
+from _typeshed import Incomplete
+from collections.abc import Iterable
+
 from . import base
 
 spaceCharacters: str
 
-class Filter(base.Filter):
+class Filter(base.Filter[dict[str, Incomplete]]):
     require_matching_tags: bool
-    def __init__(self, source, require_matching_tags: bool = True) -> None: ...
-    def __iter__(self): ...
+    def __init__(self, source: Iterable[dict[str, Incomplete]], require_matching_tags: bool = True) -> None: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/optionaltags.pyi

@@ -3,8 +3,7 @@ from collections.abc import Generator
 
 from . import base
 
-class Filter(base.Filter):
+class Filter(base.Filter[dict[str, Incomplete]]):
     def slider(self) -> Generator[tuple[Incomplete, Incomplete, Incomplete]]: ...
-    def __iter__(self): ...
     def is_optional_start(self, tagname: str, previous, next) -> bool: ...
     def is_optional_end(self, tagname: str, next) -> bool: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/sanitizer.pyi

@@ -1,4 +1,5 @@
 import re
+from _typeshed import Incomplete
 from collections.abc import Iterable
 from typing_extensions import deprecated
 
@@ -19,7 +20,7 @@ allowed_content_types: frozenset[str]
 data_content_type: re.Pattern[str]
 
 @deprecated("html5lib's sanitizer is deprecated; see https://github.com/html5lib/html5lib-python/issues/443")
-class Filter(base.Filter):
+class Filter(base.Filter[dict[str, Incomplete]]):
     allowed_elements: Iterable[tuple[str | None, str]]
     allowed_attributes: Iterable[tuple[str | None, str]]
     allowed_css_properties: Iterable[str]
@@ -32,7 +33,7 @@ class Filter(base.Filter):
     svg_allow_local_href: Iterable[tuple[str | None, str]]
     def __init__(
         self,
-        source,
+        source: Iterable[dict[str, Incomplete]],
         allowed_elements: Iterable[tuple[str | None, str]] = ...,
         allowed_attributes: Iterable[tuple[str | None, str]] = ...,
         allowed_css_properties: Iterable[str] = ...,
@@ -44,8 +45,7 @@ class Filter(base.Filter):
         svg_attr_val_allows_ref: Iterable[tuple[str | None, str]] = ...,
         svg_allow_local_href: Iterable[tuple[str | None, str]] = ...,
     ) -> None: ...
-    def __iter__(self): ...
-    def sanitize_token(self, token): ...
-    def allowed_token(self, token): ...
-    def disallowed_token(self, token): ...
+    def sanitize_token(self, token: dict[str, Incomplete]) -> dict[str, Incomplete] | None: ...
+    def allowed_token(self, token: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def disallowed_token(self, token: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
     def sanitize_css(self, style: str) -> str: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/filters/whitespace.pyi

@@ -1,12 +1,12 @@
 import re
+from _typeshed import Incomplete
 
 from . import base
 
 spaceCharacters: str
 SPACES_REGEX: re.Pattern[str]
 
-class Filter(base.Filter):
+class Filter(base.Filter[dict[str, Incomplete]]):
     spacePreserveElements: frozenset[str]
-    def __iter__(self): ...
 
 def collapse_spaces(text: str) -> str: ...

package/dist/typeshed-fallback/stubs/html5lib/html5lib/html5parser.pyi

@@ -54,9 +54,9 @@ class HTMLParser:
     def reparseTokenNormal(self, token: dict[str, Any]) -> None: ...
     def resetInsertionMode(self) -> None: ...
     originalPhase: Incomplete
-    def parseRCDataRawtext(self, token, contentType) -> None: ...
+    def parseRCDataRawtext(self, token, contentType: Literal["RAWTEXT", "RCDATA"]) -> None: ...
 
-def getPhases(debug): ...
+def getPhases(debug: bool | None) -> dict[str, type]: ...
 def adjust_attributes(token: dict[str, Any], replacements: dict[str, Any]) -> None: ...
 def impliedTagToken(
     name: str, type: str = "EndTag", attributes: dict[str, Any] | None = None, selfClosing: bool = False

package/dist/typeshed-fallback/stubs/html5lib/html5lib/serializer.pyi

@@ -1,20 +1,53 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
-from typing import overload
+from typing import Literal, overload
 
-k: str
-v: str | int
-
-def htmlentityreplace_errors(exc: Exception) -> tuple[str | bytes, int]: ...
-@overload
-def serialize(input, tree: str = "etree", encoding: None = None, **serializer_opts) -> str: ...
+def htmlentityreplace_errors(exc: UnicodeError) -> tuple[str | bytes, int]: ...
 @overload
-def serialize(input, tree: str, encoding: str, **serializer_opts) -> bytes: ...
+def serialize(
+    input,
+    tree: Literal["dom", "genshi", "lxml", "etree"] = "etree",
+    encoding: Literal[""] | None = None,
+    *,
+    quote_attr_values: Literal["legacy", "spec", "always"] = "legacy",
+    quote_char: str = '"',
+    use_best_quote_char: bool = ...,  # default value depends on whether quote_char was passed
+    omit_optional_tags: bool = True,
+    minimize_boolean_attributes: bool = True,
+    use_trailing_solidus: bool = False,
+    space_before_trailing_solidus: bool = True,
+    escape_lt_in_attrs: bool = False,
+    escape_rcdata: bool = False,
+    resolve_entities: bool = True,
+    alphabetical_attributes: bool = False,
+    inject_meta_charset: bool = True,
+    strip_whitespace: bool = False,
+    sanitize: bool = False,
+) -> str: ...
 @overload
-def serialize(input, *, encoding: str, **serializer_opts) -> bytes: ...
+def serialize(
+    input,
+    tree: Literal["dom", "genshi", "lxml", "etree"] = "etree",
+    encoding: str = ...,
+    *,
+    quote_attr_values: Literal["legacy", "spec", "always"] = "legacy",
+    quote_char: str = '"',
+    use_best_quote_char: bool = ...,  # default value depends on whether quote_char was passed
+    omit_optional_tags: bool = True,
+    minimize_boolean_attributes: bool = True,
+    use_trailing_solidus: bool = False,
+    space_before_trailing_solidus: bool = True,
+    escape_lt_in_attrs: bool = False,
+    escape_rcdata: bool = False,
+    resolve_entities: bool = True,
+    alphabetical_attributes: bool = False,
+    inject_meta_charset: bool = True,
+    strip_whitespace: bool = False,
+    sanitize: bool = False,
+) -> bytes: ...
 
 class HTMLSerializer:
-    quote_attr_values: str
+    quote_attr_values: Literal["legacy", "spec", "always"]
     quote_char: str
     use_best_quote_char: bool
     omit_optional_tags: bool
@@ -28,15 +61,38 @@ class HTMLSerializer:
     inject_meta_charset: bool
     strip_whitespace: bool
     sanitize: bool
-    options: Incomplete
-    errors: Incomplete
+    options: tuple[str, ...]
+    errors: list[Incomplete]
     strict: bool
-    def __init__(self, **kwargs) -> None: ...
-    def encode(self, string): ...
-    def encodeStrict(self, string): ...
-    encoding: Incomplete
-    def serialize(self, treewalker, encoding=None) -> Generator[Incomplete]: ...
-    def render(self, treewalker, encoding=None): ...
-    def serializeError(self, data: str = "XXX ERROR MESSAGE NEEDED") -> None: ...
+    def __init__(
+        self,
+        *,
+        quote_attr_values: Literal["legacy", "spec", "always"] = "legacy",
+        quote_char: str = '"',
+        use_best_quote_char: bool = ...,  # default value depends on whether quote_char was passed
+        omit_optional_tags: bool = True,
+        minimize_boolean_attributes: bool = True,
+        use_trailing_solidus: bool = False,
+        space_before_trailing_solidus: bool = True,
+        escape_lt_in_attrs: bool = False,
+        escape_rcdata: bool = False,
+        resolve_entities: bool = True,
+        alphabetical_attributes: bool = False,
+        inject_meta_charset: bool = True,
+        strip_whitespace: bool = False,
+        sanitize: bool = False,
+    ) -> None: ...
+    def encode(self, string: str) -> str | bytes: ...  # result depends on self.encoding
+    def encodeStrict(self, string: str) -> str | bytes: ...  # result depends on self.encoding
+    encoding: str | None
+    @overload
+    def serialize(self, treewalker, encoding: Literal[""] | None = None) -> Generator[str]: ...
+    @overload
+    def serialize(self, treewalker, encoding: str = ...) -> Generator[bytes]: ...
+    @overload
+    def render(self, treewalker, encoding: Literal[""] | None = None) -> str: ...
+    @overload
+    def render(self, treewalker, encoding: str = ...) -> bytes: ...
+    def serializeError(self, data="XXX ERROR MESSAGE NEEDED") -> None: ...
 
 class SerializeError(Exception): ...