1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
# Hand-written stub for lxml.etree as used by mypy.report.
# This is *far* from complete, and the stubgen-generated ones crash mypy.
# Any use of `Any` below means I couldn't figure out the type.
import typing
from typing import Any, Dict, List, Mapping, MutableMapping, Tuple, Union, Optional, Sequence
from typing import Iterable, Iterator, SupportsBytes
# We do *not* want `typing.AnyStr` because it is a `TypeVar`, which is an
# unnecessary constraint. It seems reasonable to constrain each
# List/Dict argument to use one type consistently, though, and it is
# necessary in order to keep these brief.
_AnyStr = Union[str]
_ListAnyStr = Union[List[str], List[bytes]]
_DictAnyStr = Union[Dict[str, str], Dict[bytes, bytes]]
_Dict_Tuple2AnyStr_Any = Union[Dict[Tuple[str, str], Any], Tuple[bytes, bytes], Any]
_xpath = Union['XPath', _AnyStr]
_OptionalNamespace = Optional[Mapping[str, Any]]
class ElementChildIterator(Iterator['_Element']):
def __iter__(self) -> 'ElementChildIterator': ...
def __next__(self) -> '_Element': ...
class _Element(Iterable['_Element']):
def addprevious(self, element: '_Element') -> None: ...
def addnext(self, element: '_Element') -> None: ...
def find(self, path: str, namespace: _OptionalNamespace = None) -> '_Element': ...
def findall(self, name: str, namespace: _OptionalNamespace = None) -> Sequence['_Element']: ...
def clear(self) -> None: ...
def get(self, key: _AnyStr, default: Optional[_AnyStr] = ...) -> _AnyStr: ...
def set(self, key: _AnyStr, value: _AnyStr) -> None: ...
def xpath(self, _path: _AnyStr, namespaces: Optional[_DictAnyStr] = ..., extensions: Any = ..., smart_strings: bool = ..., **_variables: Any) -> Any: ...
# indeed returns a Union[bool, float, _AnyStr, List[Union[ElementBase, _AnyStr, Tuple[]]]]: ...
# http://lxml.de/xpathxslt.html#xpath-return-values
attrib = ... # type: MutableMapping[str, str]
text = ... # type: _AnyStr
tag = ... # type: str
sourceline = ... # type: Optional[int]
def append(self, element: '_Element') -> '_Element': ...
def __iter__(self) -> ElementChildIterator: ...
def items(self) -> Sequence[Tuple[_AnyStr, _AnyStr]]: ...
def iterfind(self, path: str, namespace: _OptionalNamespace = None) -> Iterator['_Element']: ...
def getparent(self) -> _Element: ...
def __len__(self) -> int: ...
class ElementBase(_Element): ...
class _ElementTree:
def write(self,
file: Union[_AnyStr, typing.IO],
encoding: _AnyStr = ...,
method: _AnyStr = ...,
pretty_print: bool = ...,
xml_declaration: Any = ...,
with_tail: Any = ...,
standalone: bool = ...,
compression: int = ...,
exclusive: bool = ...,
with_comments: bool = ...,
inclusive_ns_prefixes: _ListAnyStr = ...) -> None: ...
def xpath(self, _path: _AnyStr, namespaces: Optional[_DictAnyStr] = ..., extensions: Any = ..., smart_strings: bool = ..., **_variables: Any) -> Any: ...
def getroot(self) -> _Element: ...
class _XSLTResultTree(SupportsBytes):
def __bytes__(self) -> bytes: ...
class _XSLTQuotedStringParam: ...
class XMLParser: ...
class XMLSchema:
def __init__(self,
etree: Union[_Element, _ElementTree] = ...,
file: Union[_AnyStr, typing.IO] = ...) -> None: ...
def assertValid(self, etree: Union[_Element, _ElementTree]) -> None: ...
class XSLTAccessControl: ...
class XSLT:
def __init__(self,
xslt_input: Union[_Element, _ElementTree],
extensions: _Dict_Tuple2AnyStr_Any = ...,
regexp: bool = ...,
access_control: XSLTAccessControl = ...) -> None: ...
def __call__(self,
_input: Union[_Element, _ElementTree],
profile_run: bool = ...,
**kwargs: Union[_AnyStr, _XSLTQuotedStringParam]) -> _XSLTResultTree: ...
@staticmethod
def strparam(s: _AnyStr) -> _XSLTQuotedStringParam: ...
def Element(_tag: _AnyStr,
attrib: _DictAnyStr = ...,
nsmap: _DictAnyStr = ...,
**extra: _AnyStr) -> _Element: ...
def SubElement(_parent: _Element, _tag: _AnyStr,
attrib: _DictAnyStr = ...,
nsmap: _DictAnyStr = ...,
**extra: _AnyStr) -> _Element: ...
def ElementTree(element: _Element = ...,
file: Union[_AnyStr, typing.IO] = ...,
parser: XMLParser = ...) -> _ElementTree: ...
def ProcessingInstruction(target: _AnyStr, text: _AnyStr = ...) -> _Element: ...
def parse(source: Union[_AnyStr, typing.IO],
parser: XMLParser = ...,
base_url: _AnyStr = ...) -> _ElementTree: ...
def fromstring(text: _AnyStr,
parser: XMLParser = ...,
*,
base_url: _AnyStr = ...) -> _Element: ...
def tostring(element_or_tree: Union[_Element, _ElementTree],
encoding: Union[str, type] = ...,
method: str = ...,
xml_declaration: bool = ...,
pretty_print: bool = ...,
with_tail: bool = ...,
standalone: bool = ...,
doctype: str = ...,
exclusive: bool = ...,
with_comments: bool = ...,
inclusive_ns_prefixes: Any = ...) -> _AnyStr: ...
class _ErrorLog: ...
class Error(Exception): ...
class LxmlError(Error):
def __init__(self, message: Any, error_log: _ErrorLog = ...) -> None: ...
error_log = ... # type: _ErrorLog
class DocumentInvalid(LxmlError): ...
class LxmlSyntaxError(LxmlError, SyntaxError): ...
class ParseError(LxmlSyntaxError): ...
class XMLSyntaxError(ParseError): ...
class _Validator: ...
class DTD(_Validator):
def __init__(self,
file: Union[_AnyStr, typing.IO] = ...,
*,
external_id: Any = ...) -> None: ...
def assertValid(self, etree: _Element) -> None: ...
class XPath:
def __init__(self, path: _AnyStr, namespaces: Optional[_AnyStr], extensions: Optional[_AnyStr], regexp: Optional[bool], smart_strings: Optional[bool]) -> None: ...
|
