basedpyright 1.31.7 → 1.32.0

package/dist/typeshed-fallback/stubs/networkx/networkx/readwrite/pajek.pyi

@@ -1,12 +1,13 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
 __all__ = ["read_pajek", "parse_pajek", "generate_pajek", "write_pajek"]
 
-def generate_pajek(G) -> Generator[Incomplete, None, None]: ...
-def write_pajek(G, path, encoding: str = "UTF-8") -> None: ...
+def generate_pajek(G: Graph[_Node]) -> Generator[Incomplete, None, None]: ...
+def write_pajek(G: Graph[_Node], path, encoding: str = "UTF-8") -> None: ...
 @_dispatchable
 def read_pajek(path, encoding: str = "UTF-8"): ...
 @_dispatchable

package/dist/typeshed-fallback/stubs/networkx/networkx/readwrite/sparse6.pyi

@@ -1,14 +1,13 @@
 from _typeshed import Incomplete
 
+from networkx.classes.graph import Graph, _Node
 from networkx.utils.backends import _dispatchable
 
-from ..classes.graph import Graph
-
 __all__ = ["from_sparse6_bytes", "read_sparse6", "to_sparse6_bytes", "write_sparse6"]
 
 @_dispatchable
 def from_sparse6_bytes(string) -> Graph[Incomplete]: ...
-def to_sparse6_bytes(G, nodes=None, header: bool = True): ...
+def to_sparse6_bytes(G: Graph[_Node], nodes=None, header: bool = True): ...
 @_dispatchable
 def read_sparse6(path): ...
-def write_sparse6(G, path, nodes=None, header: bool = True) -> None: ...
+def write_sparse6(G: Graph[_Node], path, nodes=None, header: bool = True) -> None: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/backends.pyi

@@ -52,7 +52,7 @@ class _dispatchable(Generic[_P, _R]):
     def __signature__(self): ...
     # Type system limitations doesn't allow us to define this as it truly should.
     # But specifying backend with backend_kwargs isn't a common usecase anyway
-    # and specifying backend as explicitely None is possible but not intended.
+    # and specifying backend as explicitly None is possible but not intended.
     # If this ever changes, update stubs/networkx/@tests/test_cases/check_dispatch_decorator.py
     @overload
     def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/misc.pyi

@@ -4,6 +4,7 @@ from types import ModuleType
 from typing_extensions import Self, TypeAlias
 
 import numpy
+from networkx.classes.graph import Graph, _Node
 
 __all__ = [
     "flatten",
@@ -60,4 +61,4 @@ def create_py_random_state(random_state: _RandomState = None): ...
 def nodes_equal(nodes1, nodes2) -> bool: ...
 def edges_equal(edges1, edges2) -> bool: ...
 def graphs_equal(graph1, graph2) -> bool: ...
-def _clear_cache(G) -> None: ...
+def _clear_cache(G: Graph[_Node]) -> None: ...

package/dist/typeshed-fallback/stubs/networkx/networkx/utils/rcm.pyi

@@ -5,7 +5,7 @@ from networkx.classes.graph import Graph, _Node
 
 __all__ = ["cuthill_mckee_ordering", "reverse_cuthill_mckee_ordering"]
 
-def cuthill_mckee_ordering(G, heuristic=None) -> Generator[Incomplete, Incomplete, None]: ...
-def reverse_cuthill_mckee_ordering(G, heuristic=None): ...
+def cuthill_mckee_ordering(G: Graph[_Node], heuristic=None) -> Generator[Incomplete, Incomplete, None]: ...
+def reverse_cuthill_mckee_ordering(G: Graph[_Node], heuristic=None): ...
 def connected_cuthill_mckee_ordering(G: Graph[_Node], heuristic=None): ...
 def pseudo_peripheral_node(G: Graph[_Node]): ...

package/dist/typeshed-fallback/stubs/psutil/psutil/__init__.pyi

@@ -2,7 +2,7 @@ import sys
 from _typeshed import Incomplete
 from collections.abc import Callable, Iterable, Iterator
 from contextlib import AbstractContextManager
-from typing import Any, Literal, overload
+from typing import Any, Literal, Protocol, overload, type_check_only
 from typing_extensions import Self, TypeAlias, deprecated
 
 from psutil._common import (
@@ -234,11 +234,18 @@ class Popen(Process):
     def __getattribute__(self, name: str) -> Any: ...
     def __dir__(self) -> list[str]: ...
 
+@type_check_only
+class _ProcessIterCallable(Protocol):
+    def __call__(
+        self, attrs: list[str] | tuple[str, ...] | set[str] | frozenset[str] | None = None, ad_value=None
+    ) -> Iterator[Process]: ...
+    def cache_clear(self) -> None: ...
+
 def pids() -> list[int]: ...
 def pid_exists(pid: int) -> bool: ...
-def process_iter(
-    attrs: list[str] | tuple[str, ...] | set[str] | frozenset[str] | None = None, ad_value=None
-) -> Iterator[Process]: ...
+
+process_iter: _ProcessIterCallable
+
 def wait_procs(
     procs: Iterable[Process], timeout: float | None = None, callback: Callable[[Process], object] | None = None
 ) -> tuple[list[Process], list[Process]]: ...

package/dist/typeshed-fallback/stubs/psycopg2/METADATA.toml

@@ -1,3 +1,3 @@
-version = "~= 2.9.10"
+version = "2.9.11"
 upstream_repository = "https://github.com/psycopg/psycopg2"
 partial_stub = false

package/dist/typeshed-fallback/stubs/psycopg2/psycopg2/errorcodes.pyi

@@ -14,6 +14,7 @@ CLASS_LOCATOR_EXCEPTION: Final[str]
 CLASS_INVALID_GRANTOR: Final[str]
 CLASS_INVALID_ROLE_SPECIFICATION: Final[str]
 CLASS_DIAGNOSTICS_EXCEPTION: Final[str]
+CLASS_XQUERY_ERROR: Final[str]
 CLASS_CASE_NOT_FOUND: Final[str]
 CLASS_CARDINALITY_VIOLATION: Final[str]
 CLASS_DATA_EXCEPTION: Final[str]
@@ -74,6 +75,7 @@ INVALID_GRANT_OPERATION: Final[str]
 INVALID_ROLE_SPECIFICATION: Final[str]
 DIAGNOSTICS_EXCEPTION: Final[str]
 STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER: Final[str]
+INVALID_ARGUMENT_FOR_XQUERY: Final[str]
 CASE_NOT_FOUND: Final[str]
 CARDINALITY_VIOLATION: Final[str]
 DATA_EXCEPTION: Final[str]
@@ -266,6 +268,7 @@ SYSTEM_ERROR: Final[str]
 IO_ERROR: Final[str]
 UNDEFINED_FILE: Final[str]
 DUPLICATE_FILE: Final[str]
+FILE_NAME_TOO_LONG: Final[str]
 SNAPSHOT_TOO_OLD: Final[str]
 CONFIG_FILE_ERROR: Final[str]
 LOCK_FILE_EXISTS: Final[str]

package/dist/typeshed-fallback/stubs/pyserial/serial/rfc2217.pyi

@@ -183,5 +183,5 @@ class PortManager:
     def telnet_send_option(self, action: bytes, option: bytes) -> None: ...
     def rfc2217_send_subnegotiation(self, option: bytes, value: bytes = b"") -> None: ...
     def check_modem_lines(self, force_notification: bool = False) -> None: ...
-    def escape(self, data: bytes) -> Generator[bytes, None, None]: ...
-    def filter(self, data: bytes) -> Generator[bytes, None, None]: ...
+    def escape(self, data: bytes) -> Generator[bytes]: ...
+    def filter(self, data: bytes) -> Generator[bytes]: ...

package/dist/typeshed-fallback/stubs/pyserial/serial/serialutil.pyi

@@ -149,4 +149,4 @@ class SerialBase(io.RawIOBase):
     def send_break(self, duration: float = 0.25) -> None: ...
     def read_all(self) -> bytes | None: ...
     def read_until(self, expected: bytes = b"\n", size: int | None = None) -> bytes: ...
-    def iread_until(self, expected: bytes = ..., size: int | None = ...) -> Generator[bytes, None, None]: ...
+    def iread_until(self, expected: bytes = ..., size: int | None = ...) -> Generator[bytes]: ...

package/dist/typeshed-fallback/stubs/pyserial/serial/tools/list_ports.pyi

@@ -2,10 +2,12 @@ import re
 import sys
 from collections.abc import Generator
 
+from serial.tools.list_ports_common import ListPortInfo
+
 if sys.platform == "win32":
     from serial.tools.list_ports_windows import comports as comports
 else:
     from serial.tools.list_ports_posix import comports as comports
 
-def grep(regexp: str | re.Pattern[str], include_links: bool = False) -> Generator[tuple[str, str, str], None, None]: ...
+def grep(regexp: str | re.Pattern[str], include_links: bool = False) -> Generator[ListPortInfo]: ...
 def main() -> None: ...

package/dist/typeshed-fallback/stubs/pyserial/serial/tools/list_ports_windows.pyi

@@ -74,5 +74,5 @@ if sys.platform == "win32":
         depth: int = 0,
         last_serial_number: str | None = None,
     ) -> str: ...
-    def iterate_comports() -> Generator[ListPortInfo, None, None]: ...
+    def iterate_comports() -> Generator[ListPortInfo]: ...
     def comports(include_links: bool = False) -> list[ListPortInfo]: ...

package/dist/typeshed-fallback/stubs/pyserial/serial/urlhandler/protocol_spy.pyi

@@ -3,8 +3,8 @@ from typing import TextIO, type_check_only
 
 import serial
 
-def sixteen(data: bytes) -> Generator[tuple[str, str] | tuple[None, None], None, None]: ...
-def hexdump(data: bytes) -> Generator[tuple[int, str], None, None]: ...
+def sixteen(data: bytes) -> Generator[tuple[str, str] | tuple[None, None]]: ...
+def hexdump(data: bytes) -> Generator[tuple[int, str]]: ...
 @type_check_only
 class _Formatter:
     def rx(self, data: bytes) -> None: ...

package/dist/typeshed-fallback/stubs/python-dateutil/dateutil/rrule.pyi

@@ -1,7 +1,7 @@
 import datetime
 from _typeshed import Incomplete
 from collections.abc import Generator, Iterable, Iterator, Sequence
-from typing import Final, Literal
+from typing import Final, Literal, overload
 from typing_extensions import Self, TypeAlias
 
 from ._common import weekday as weekdaybase
@@ -174,6 +174,35 @@ class rruleset(rrulebase):
     def exdate(self, exdate) -> None: ...
 
 class _rrulestr:
+    @overload
+    def __call__(
+        self,
+        s: str,
+        *,
+        forceset: Literal[True],
+        dtstart: datetime.date | None = None,
+        cache: bool | None = None,
+        unfold: bool = False,
+        compatible: bool = False,
+        ignoretz: bool = False,
+        tzids=None,
+        tzinfos=None,
+    ) -> rruleset: ...
+    @overload
+    def __call__(
+        self,
+        s: str,
+        *,
+        compatible: Literal[True],
+        dtstart: datetime.date | None = None,
+        cache: bool | None = None,
+        unfold: bool = False,
+        forceset: bool = False,
+        ignoretz: bool = False,
+        tzids=None,
+        tzinfos=None,
+    ) -> rruleset: ...
+    @overload
     def __call__(
         self,
         s: str,

package/dist/typeshed-fallback/stubs/pywin32/win32/win32pipe.pyi

@@ -34,7 +34,7 @@ def CreateNamedPipe(
 def DisconnectNamedPipe(hFile: int, /) -> None: ...
 def GetOverlappedResult(hFile: int, overlapped: _win32typing.PyOVERLAPPED, bWait: int | bool, /) -> int: ...
 def WaitNamedPipe(pipeName: str, timeout, /) -> None: ...
-def GetNamedPipeInfo(hNamedPipe: int, /) -> tuple[Incomplete, Incomplete, Incomplete, Incomplete]: ...
+def GetNamedPipeInfo(hNamedPipe: int, /) -> tuple[int, int, int, int]: ...
 def PeekNamedPipe(hPipe: int, size: int, /) -> tuple[str, int, Incomplete]: ...
 def GetNamedPipeClientProcessId(hPipe: int, /): ...
 def GetNamedPipeServerProcessId(hPipe: int, /): ...

package/dist/typeshed-fallback/stubs/six/six/__init__.pyi

@@ -61,7 +61,7 @@ unichr = chr
 
 def int2byte(i: int) -> bytes: ...
 
-# Should be `byte2int: operator.itemgetter[int]`. But a bug in mypy prevents using TypeVar in itemgetter.__call__
+# Should be `byte2int: operator.itemgetter[int]`. But `itemgetter.__call__` returns `Any`
 def byte2int(obj: SupportsGetItem[int, _T]) -> _T: ...
 
 indexbytes = operator.getitem

package/dist/typeshed-fallback/stubs/www-authenticate/METADATA.toml

@@ -0,0 +1,2 @@
+version = "0.9.*"
+upstream_repository = "https://github.com/alexsdutton/www-authenticate"

package/dist/typeshed-fallback/stubs/www-authenticate/www_authenticate.pyi

@@ -0,0 +1,34 @@
+from _typeshed import Incomplete
+from collections import OrderedDict
+from typing import Protocol, TypeVar, overload, type_check_only
+
+_T = TypeVar("_T")
+_VT = TypeVar("_VT")
+
+@type_check_only
+class _SupportsCasefold(Protocol):
+    def casefold(self) -> str: ...
+
+@type_check_only
+class _SupportsLower(Protocol):
+    def lower(self) -> str: ...
+
+class CaseFoldedOrderedDict(OrderedDict[str, _VT]):
+    def __getitem__(self, key: _SupportsCasefold | _SupportsLower) -> _VT: ...
+    def __setitem__(self, key: _SupportsCasefold | _SupportsLower, value: _VT) -> None: ...
+    def __contains__(self, key: _SupportsCasefold | _SupportsLower) -> bool: ...  # type: ignore[override]
+    # See overloads for dict class:
+    @overload
+    def get(self, key: _SupportsCasefold | _SupportsLower, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _SupportsCasefold | _SupportsLower, default: _VT) -> _VT: ...
+    @overload
+    def get(self, key: _SupportsCasefold | _SupportsLower, default: _T) -> _VT | _T: ...
+    @overload  # type: ignore[override]
+    def pop(self, key: _SupportsCasefold | _SupportsLower, default: None = None) -> _VT | None: ...
+    @overload
+    def pop(self, key: _SupportsCasefold | _SupportsLower, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _SupportsCasefold | _SupportsLower, default: _T) -> _VT | _T: ...
+
+def parse(value: str) -> CaseFoldedOrderedDict[Incomplete]: ...

package/dist/typeshed-fallback/stubs/xlrd/xlrd/sheet.pyi

@@ -1,6 +1,6 @@
 from _typeshed import SupportsWrite
 from array import array
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Generator, Sequence
 from typing import Any, Final, Literal, overload
 
 from .biffh import *
@@ -43,10 +43,10 @@ ctype_text: Final[dict[int, str]]
 
 class Cell(BaseObject):
     __slots__ = ["ctype", "value", "xf_index"]
-    ctype: int
-    value: str
+    ctype: Literal[0, 1, 2, 3, 4, 5, 6]
+    value: str | float
     xf_index: int | None
-    def __init__(self, ctype: int, value: str, xf_index: int | None = None) -> None: ...
+    def __init__(self, ctype: Literal[0, 1, 2, 3, 4, 5, 6], value: str, xf_index: int | None = None) -> None: ...
 
 empty_cell: Final[Cell]
 
@@ -147,7 +147,7 @@ class Sheet(BaseObject):
     def __getitem__(self, item: int) -> list[Cell]: ...
     @overload
     def __getitem__(self, item: tuple[int, int]) -> Cell: ...
-    def get_rows(self) -> tuple[list[Cell], ...]: ...
+    def get_rows(self) -> Generator[list[Cell]]: ...
     __iter__ = get_rows
     def row_types(self, rowx: int, start_colx: int = 0, end_colx: int | None = None) -> Sequence[int]: ...
     def row_values(self, rowx: int, start_colx: int = 0, end_colx: int | None = None) -> Sequence[str]: ...

package/dist/typeshed-fallback/stubs/xmldiff/METADATA.toml

@@ -0,0 +1,2 @@
+version = "2.7.*"
+upstream_repository = "https://github.com/Shoobx/xmldiff"

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/actions.pyi

@@ -0,0 +1,58 @@
+from _typeshed import Incomplete
+from typing import NamedTuple
+
+class DeleteNode(NamedTuple):
+    node: str
+
+class InsertNode(NamedTuple):
+    target: Incomplete
+    tag: str
+    position: int
+
+class RenameNode(NamedTuple):
+    node: str
+    tag: Incomplete
+
+class MoveNode(NamedTuple):
+    node: str
+    target: Incomplete
+    position: int
+
+class UpdateTextIn(NamedTuple):
+    node: str
+    text: Incomplete
+
+class UpdateTextAfter(NamedTuple):
+    node: str
+    text: Incomplete
+
+class UpdateAttrib(NamedTuple):
+    node: str
+    name: str
+    value: Incomplete
+
+class DeleteAttrib(NamedTuple):
+    node: str
+    name: str
+
+class InsertAttrib(NamedTuple):
+    node: str
+    name: str
+    value: Incomplete
+
+class RenameAttrib(NamedTuple):
+    node: str
+    oldname: str
+    newname: str
+
+class InsertComment(NamedTuple):
+    target: Incomplete
+    position: Incomplete
+    text: Incomplete
+
+class InsertNamespace(NamedTuple):
+    prefix: str
+    uri: str
+
+class DeleteNamespace(NamedTuple):
+    prefix: str

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/diff.pyi

@@ -0,0 +1,36 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+from typing import Literal
+
+class Differ:
+    F: float
+    uniqueattrs: Incomplete
+    fast_match: Incomplete
+    best_match: Incomplete
+    ignored_attrs: Incomplete
+    def __init__(
+        self,
+        F: float | None = None,
+        uniqueattrs=None,
+        ratio_mode: Literal["accurate", "fast", "faster"] = "fast",
+        fast_match: bool = False,
+        best_match: bool = False,
+        ignored_attrs=[],
+    ) -> None: ...
+    left: Incomplete
+    right: Incomplete
+    def clear(self) -> None: ...
+    def set_trees(self, left, right) -> None: ...
+    def append_match(self, lnode, rnode, max_match) -> None: ...
+    def match(self, left=None, right=None): ...
+    def node_ratio(self, left, right): ...
+    def node_text(self, node): ...
+    def node_attribs(self, node): ...
+    def leaf_ratio(self, left, right): ...
+    def child_ratio(self, left, right): ...
+    def update_node_tag(self, left, right) -> Generator[Incomplete]: ...
+    def update_node_attr(self, left, right) -> Generator[Incomplete]: ...
+    def update_node_text(self, left, right) -> Generator[Incomplete]: ...
+    def find_pos(self, node): ...
+    def align_children(self, left, right) -> Generator[Incomplete, None, Incomplete]: ...
+    def diff(self, left=None, right=None) -> Generator[Incomplete, Incomplete]: ...

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/diff_match_patch.pyi

@@ -0,0 +1,58 @@
+from _typeshed import Incomplete
+
+class diff_match_patch:
+    Diff_Timeout: float
+    Diff_EditCost: int
+    Match_Threshold: float
+    Match_Distance: int
+    Patch_DeleteThreshold: float
+    Patch_Margin: int
+    Match_MaxBits: int
+    def __init__(self) -> None: ...
+    DIFF_DELETE: int
+    DIFF_INSERT: int
+    DIFF_EQUAL: int
+    DIFF_REPLACE: int
+    def diff_main(self, text1, text2, checklines: bool = True, deadline=None): ...
+    def diff_compute(self, text1, text2, checklines, deadline): ...
+    def diff_lineMode(self, text1, text2, deadline): ...
+    def diff_bisect(self, text1, text2, deadline): ...
+    def diff_bisectSplit(self, text1, text2, x, y, deadline): ...
+    def diff_linesToChars(self, text1, text2): ...
+    def diff_charsToLines(self, diffs, lineArray) -> None: ...
+    def diff_commonPrefix(self, text1, text2): ...
+    def diff_commonSuffix(self, text1, text2): ...
+    def diff_commonOverlap(self, text1, text2): ...
+    def diff_halfMatch(self, text1, text2): ...
+    def diff_cleanupSemantic(self, diffs) -> None: ...
+    def diff_cleanupSemanticLossless(self, diffs): ...
+    BLANKLINEEND: Incomplete
+    BLANKLINESTART: Incomplete
+    def diff_cleanupEfficiency(self, diffs) -> None: ...
+    def diff_cleanupMerge(self, diffs) -> None: ...
+    def diff_xIndex(self, diffs, loc): ...
+    def diff_prettyHtml(self, diffs): ...
+    def diff_text1(self, diffs): ...
+    def diff_text2(self, diffs): ...
+    def diff_levenshtein(self, diffs): ...
+    def diff_toDelta(self, diffs): ...
+    def diff_fromDelta(self, text1, delta): ...
+    def match_main(self, text, pattern, loc): ...
+    def match_bitap(self, text, pattern, loc): ...
+    def match_alphabet(self, pattern): ...
+    def patch_addContext(self, patch, text) -> None: ...
+    def patch_make(self, a, b=None, c=None): ...
+    def patch_deepCopy(self, patches): ...
+    def patch_apply(self, patches, text): ...
+    def patch_addPadding(self, patches): ...
+    def patch_splitMax(self, patches) -> None: ...
+    def patch_toText(self, patches): ...
+    def patch_fromText(self, textline): ...
+
+class patch_obj:
+    diffs: Incomplete
+    start1: Incomplete
+    start2: Incomplete
+    length1: int
+    length2: int
+    def __init__(self) -> None: ...

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/formatting.pyi

@@ -0,0 +1,80 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+from typing import Final, NamedTuple
+
+DIFF_NS: Final[str]
+DIFF_PREFIX: Final[str]
+INSERT_NAME: Final[Incomplete]
+DELETE_NAME: Final[Incomplete]
+REPLACE_NAME: Final[Incomplete]
+RENAME_NAME: Final[Incomplete]
+WS_BOTH: Final[int]
+WS_TEXT: Final[int]
+WS_TAGS: Final[int]
+WS_NONE: Final[int]
+T_OPEN: Final[int]
+T_CLOSE: Final[int]
+T_SINGLE: Final[int]
+PLACEHOLDER_START: Final[int]
+
+class BaseFormatter:
+    def __init__(self, normalize=1, pretty_print: bool = False) -> None: ...
+    def prepare(self, left_tree, right_tree) -> None: ...
+    def format(self, diff, orig_tree) -> None: ...
+
+class PlaceholderEntry(NamedTuple):
+    element: Incomplete
+    ttype: Incomplete
+    close_ph: Incomplete
+
+class PlaceholderMaker:
+    text_tags: Incomplete
+    formatting_tags: Incomplete
+    placeholder2tag: Incomplete
+    tag2placeholder: Incomplete
+    placeholder: Incomplete
+    diff_tags: Incomplete
+    def __init__(self, text_tags=(), formatting_tags=()) -> None: ...
+    def get_placeholder(self, element, ttype, close_ph): ...
+    def is_placeholder(self, char): ...
+    def is_formatting(self, element): ...
+    def do_element(self, element) -> None: ...
+    def do_tree(self, tree) -> None: ...
+    def split_string(self, text): ...
+    def undo_string(self, text): ...
+    def undo_element(self, elem) -> None: ...
+    def undo_tree(self, tree) -> None: ...
+    def mark_diff(self, ph, action, attributes=None): ...
+    def wrap_diff(self, text, action, attributes=None): ...
+
+class XMLFormatter(BaseFormatter):
+    normalize: Incomplete
+    pretty_print: Incomplete
+    text_tags: Incomplete
+    formatting_tags: Incomplete
+    use_replace: Incomplete
+    placeholderer: Incomplete
+    def __init__(
+        self, normalize=0, pretty_print: bool = True, text_tags=(), formatting_tags=(), use_replace: bool = False
+    ) -> None: ...
+    def prepare(self, left_tree, right_tree) -> None: ...
+    def finalize(self, result_tree) -> None: ...
+    def format(self, diff, orig_tree, differ=None): ...
+    def render(self, result): ...
+    def handle_action(self, action, result) -> None: ...
+
+class DiffFormatter(BaseFormatter):
+    normalize: Incomplete
+    def __init__(self, normalize=1, pretty_print: bool = False) -> None: ...
+    def prepare(self, left, right) -> None: ...
+    def finalize(self, left, right) -> None: ...
+    def format(self, diff, orig_tree): ...
+    def handle_action(self, action): ...
+
+class XmlDiffFormatter(BaseFormatter):
+    normalize: Incomplete
+    def __init__(self, normalize=1, pretty_print: bool = False) -> None: ...
+    def prepare(self, left, right) -> None: ...
+    def finalize(self, left, right) -> None: ...
+    def format(self, diff, orig_tree): ...
+    def handle_action(self, action, orig_tree) -> Generator[Incomplete, Incomplete]: ...

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/main.pyi

@@ -0,0 +1,70 @@
+from argparse import ArgumentParser
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+from xmldiff.actions import (
+    DeleteAttrib,
+    DeleteNamespace,
+    DeleteNode,
+    InsertAttrib,
+    InsertComment,
+    InsertNamespace,
+    InsertNode,
+    MoveNode,
+    RenameAttrib,
+    RenameNode,
+    UpdateAttrib,
+    UpdateTextAfter,
+    UpdateTextIn,
+)
+from xmldiff.formatting import BaseFormatter
+
+__version__: str
+FORMATTERS: Mapping[str, BaseFormatter]
+
+_ACTIONS: TypeAlias = (
+    DeleteNode
+    | InsertNode
+    | RenameNode
+    | MoveNode
+    | UpdateTextIn
+    | UpdateTextAfter
+    | UpdateAttrib
+    | DeleteAttrib
+    | InsertAttrib
+    | RenameAttrib
+    | InsertComment
+    | InsertNamespace
+    | DeleteNamespace
+)
+_ET: TypeAlias = Any  # lxml.etree._ElementTree
+
+@overload
+def diff_trees(left: _ET, right: _ET, *, diff_options: dict[str, Any] | None = None, formatter: BaseFormatter) -> str: ...
+@overload
+def diff_trees(
+    left: _ET, right: _ET, diff_options: dict[str, Any] | None = None, formatter: None = None
+) -> Iterable[_ACTIONS]: ...
+@overload
+def diff_texts(
+    left: str | bytes, right: str | bytes, *, diff_options: dict[str, Any] | None = None, formatter: BaseFormatter
+) -> str: ...
+@overload
+def diff_texts(
+    left: str | bytes, right: str | bytes, diff_options: dict[str, Any] | None = None, formatter: None = None
+) -> Iterable[_ACTIONS]: ...
+@overload
+def diff_files(left: str, right: str, *, diff_options: dict[str, Any] | None = None, formatter: BaseFormatter) -> str: ...
+@overload
+def diff_files(
+    left: str, right: str, diff_options: dict[str, Any] | None = None, formatter: None = None
+) -> Iterable[_ACTIONS]: ...
+def validate_F(arg: float | str) -> float: ...
+def make_diff_parser() -> ArgumentParser: ...
+def diff_command(args: Sequence[str] | None = None) -> int | None: ...
+def patch_tree(actions, tree): ...
+def patch_text(actions, tree): ...
+def patch_file(actions, tree, diff_encoding=None): ...
+def make_patch_parser(): ...
+def patch_command(args=None) -> None: ...

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/patch.pyi

@@ -0,0 +1,12 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+
+class Patcher:
+    @property
+    def nsmap(self): ...
+    def patch(self, actions, tree): ...
+    def handle_action(self, action, tree) -> None: ...
+
+class DiffParser:
+    def parse(self, diff) -> Generator[Incomplete]: ...
+    def make_action(self, line): ...

package/dist/typeshed-fallback/stubs/xmldiff/xmldiff/utils.pyi

@@ -0,0 +1,16 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+from re import Pattern
+
+RESERVED_NS: Pattern[str]
+
+def post_order_traverse(node) -> Generator[Incomplete, Incomplete]: ...
+def reverse_post_order_traverse(node) -> Generator[Incomplete, Incomplete]: ...
+def breadth_first_traverse(node) -> Generator[Incomplete]: ...
+def longest_common_subsequence(left_sequence, right_sequence, eqfn=...): ...
+
+WHITESPACE: Incomplete
+
+def cleanup_whitespace(text): ...
+def getpath(element, tree=None): ...
+def make_ascii_tree(element): ...