|
|
|
|
@ -2720,9 +2720,217 @@ if sys.version_info < (2, 7):
|
|
|
|
|
xpath = xpath.encode('ascii')
|
|
|
|
|
return xpath
|
|
|
|
|
|
|
|
|
|
def compat_etree_iterfind(element, match):
|
|
|
|
|
for from_ in element.findall(match):
|
|
|
|
|
yield from_
|
|
|
|
|
# further code below based on CPython 2.7 source
|
|
|
|
|
import functools
|
|
|
|
|
|
|
|
|
|
_xpath_tokenizer_re = re.compile(r'''(?x)
|
|
|
|
|
( # (1)
|
|
|
|
|
'[^']*'|"[^"]*"| # quoted strings, or
|
|
|
|
|
::|//?|\.\.|\(\)|[/.*:[\]()@=] # navigation specials
|
|
|
|
|
)| # or (2)
|
|
|
|
|
((?:\{[^}]+\})?[^/[\]()@=\s]+)| # token: optional {ns}, no specials
|
|
|
|
|
\s+ # or white space
|
|
|
|
|
''')
|
|
|
|
|
|
|
|
|
|
def _xpath_tokenizer(pattern, namespaces=None):
|
|
|
|
|
for token in _xpath_tokenizer_re.findall(pattern):
|
|
|
|
|
tag = token[1]
|
|
|
|
|
if tag and tag[0] != "{" and ":" in tag:
|
|
|
|
|
try:
|
|
|
|
|
if not namespaces:
|
|
|
|
|
raise KeyError
|
|
|
|
|
prefix, uri = tag.split(":", 1)
|
|
|
|
|
yield token[0], "{%s}%s" % (namespaces[prefix], uri)
|
|
|
|
|
except KeyError:
|
|
|
|
|
raise SyntaxError("prefix %r not found in prefix map" % prefix)
|
|
|
|
|
else:
|
|
|
|
|
yield token
|
|
|
|
|
|
|
|
|
|
def _get_parent_map(context):
|
|
|
|
|
parent_map = context.parent_map
|
|
|
|
|
if parent_map is None:
|
|
|
|
|
context.parent_map = parent_map = {}
|
|
|
|
|
for p in context.root.getiterator():
|
|
|
|
|
for e in p:
|
|
|
|
|
parent_map[e] = p
|
|
|
|
|
return parent_map
|
|
|
|
|
|
|
|
|
|
def _select(context, result, filter_fn=lambda *_: True):
|
|
|
|
|
for elem in result:
|
|
|
|
|
for e in elem:
|
|
|
|
|
if filter_fn(e, elem):
|
|
|
|
|
yield e
|
|
|
|
|
|
|
|
|
|
def _prepare_child(next_, token):
|
|
|
|
|
tag = token[1]
|
|
|
|
|
return functools.partial(_select, filter_fn=lambda e, _: e.tag == tag)
|
|
|
|
|
|
|
|
|
|
def _prepare_star(next_, token):
|
|
|
|
|
return _select
|
|
|
|
|
|
|
|
|
|
def _prepare_self(next_, token):
|
|
|
|
|
return lambda _, result: (e for e in result)
|
|
|
|
|
|
|
|
|
|
def _prepare_descendant(next_, token):
|
|
|
|
|
token = next(next_)
|
|
|
|
|
if token[0] == "*":
|
|
|
|
|
tag = "*"
|
|
|
|
|
elif not token[0]:
|
|
|
|
|
tag = token[1]
|
|
|
|
|
else:
|
|
|
|
|
raise SyntaxError("invalid descendant")
|
|
|
|
|
|
|
|
|
|
def select(context, result):
|
|
|
|
|
for elem in result:
|
|
|
|
|
for e in elem.getiterator(tag):
|
|
|
|
|
if e is not elem:
|
|
|
|
|
yield e
|
|
|
|
|
return select
|
|
|
|
|
|
|
|
|
|
def _prepare_parent(next_, token):
|
|
|
|
|
def select(context, result):
|
|
|
|
|
# FIXME: raise error if .. is applied at toplevel?
|
|
|
|
|
parent_map = _get_parent_map(context)
|
|
|
|
|
result_map = {}
|
|
|
|
|
for elem in result:
|
|
|
|
|
if elem in parent_map:
|
|
|
|
|
parent = parent_map[elem]
|
|
|
|
|
if parent not in result_map:
|
|
|
|
|
result_map[parent] = None
|
|
|
|
|
yield parent
|
|
|
|
|
return select
|
|
|
|
|
|
|
|
|
|
def _prepare_predicate(next_, token):
|
|
|
|
|
signature = []
|
|
|
|
|
predicate = []
|
|
|
|
|
for token in next_:
|
|
|
|
|
if token[0] == "]":
|
|
|
|
|
break
|
|
|
|
|
if token[0] and token[0][:1] in "'\"":
|
|
|
|
|
token = "'", token[0][1:-1]
|
|
|
|
|
signature.append(token[0] or "-")
|
|
|
|
|
predicate.append(token[1])
|
|
|
|
|
|
|
|
|
|
def select(context, result, filter_fn=lambda _: True):
|
|
|
|
|
for elem in result:
|
|
|
|
|
if filter_fn(elem):
|
|
|
|
|
yield elem
|
|
|
|
|
|
|
|
|
|
signature = "".join(signature)
|
|
|
|
|
# use signature to determine predicate type
|
|
|
|
|
if signature == "@-":
|
|
|
|
|
# [@attribute] predicate
|
|
|
|
|
key = predicate[1]
|
|
|
|
|
return functools.partial(
|
|
|
|
|
select, filter_fn=lambda el: el.get(key) is not None)
|
|
|
|
|
if signature == "@-='":
|
|
|
|
|
# [@attribute='value']
|
|
|
|
|
key = predicate[1]
|
|
|
|
|
value = predicate[-1]
|
|
|
|
|
return functools.partial(
|
|
|
|
|
select, filter_fn=lambda el: el.get(key) == value)
|
|
|
|
|
if signature == "-" and not re.match(r"\d+$", predicate[0]):
|
|
|
|
|
# [tag]
|
|
|
|
|
tag = predicate[0]
|
|
|
|
|
return functools.partial(
|
|
|
|
|
select, filter_fn=lambda el: el.find(tag) is not None)
|
|
|
|
|
if signature == "-='" and not re.match(r"\d+$", predicate[0]):
|
|
|
|
|
# [tag='value']
|
|
|
|
|
tag = predicate[0]
|
|
|
|
|
value = predicate[-1]
|
|
|
|
|
|
|
|
|
|
def itertext(el):
|
|
|
|
|
for e in el.getiterator():
|
|
|
|
|
e = e.text
|
|
|
|
|
if e:
|
|
|
|
|
yield e
|
|
|
|
|
|
|
|
|
|
def select(context, result):
|
|
|
|
|
for elem in result:
|
|
|
|
|
for e in elem.findall(tag):
|
|
|
|
|
if "".join(itertext(e)) == value:
|
|
|
|
|
yield elem
|
|
|
|
|
break
|
|
|
|
|
return select
|
|
|
|
|
if signature == "-" or signature == "-()" or signature == "-()-":
|
|
|
|
|
# [index] or [last()] or [last()-index]
|
|
|
|
|
if signature == "-":
|
|
|
|
|
index = int(predicate[0]) - 1
|
|
|
|
|
else:
|
|
|
|
|
if predicate[0] != "last":
|
|
|
|
|
raise SyntaxError("unsupported function")
|
|
|
|
|
if signature == "-()-":
|
|
|
|
|
try:
|
|
|
|
|
index = int(predicate[2]) - 1
|
|
|
|
|
except ValueError:
|
|
|
|
|
raise SyntaxError("unsupported expression")
|
|
|
|
|
else:
|
|
|
|
|
index = -1
|
|
|
|
|
|
|
|
|
|
def select(context, result):
|
|
|
|
|
parent_map = _get_parent_map(context)
|
|
|
|
|
for elem in result:
|
|
|
|
|
try:
|
|
|
|
|
parent = parent_map[elem]
|
|
|
|
|
# FIXME: what if the selector is "*" ?
|
|
|
|
|
elems = list(parent.findall(elem.tag))
|
|
|
|
|
if elems[index] is elem:
|
|
|
|
|
yield elem
|
|
|
|
|
except (IndexError, KeyError):
|
|
|
|
|
pass
|
|
|
|
|
return select
|
|
|
|
|
raise SyntaxError("invalid predicate")
|
|
|
|
|
|
|
|
|
|
ops = {
|
|
|
|
|
"": _prepare_child,
|
|
|
|
|
"*": _prepare_star,
|
|
|
|
|
".": _prepare_self,
|
|
|
|
|
"..": _prepare_parent,
|
|
|
|
|
"//": _prepare_descendant,
|
|
|
|
|
"[": _prepare_predicate,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_cache = {}
|
|
|
|
|
|
|
|
|
|
class _SelectorContext:
|
|
|
|
|
parent_map = None
|
|
|
|
|
|
|
|
|
|
def __init__(self, root):
|
|
|
|
|
self.root = root
|
|
|
|
|
|
|
|
|
|
##
|
|
|
|
|
# Generate all matching objects.
|
|
|
|
|
|
|
|
|
|
def compat_etree_iterfind(elem, path, namespaces=None):
|
|
|
|
|
# compile selector pattern
|
|
|
|
|
if path[-1:] == "/":
|
|
|
|
|
path = path + "*" # implicit all (FIXME: keep this?)
|
|
|
|
|
try:
|
|
|
|
|
selector = _cache[path]
|
|
|
|
|
except KeyError:
|
|
|
|
|
if len(_cache) > 100:
|
|
|
|
|
_cache.clear()
|
|
|
|
|
if path[:1] == "/":
|
|
|
|
|
raise SyntaxError("cannot use absolute path on element")
|
|
|
|
|
tokens = _xpath_tokenizer(path, namespaces)
|
|
|
|
|
selector = []
|
|
|
|
|
for token in tokens:
|
|
|
|
|
if token[0] == "/":
|
|
|
|
|
continue
|
|
|
|
|
try:
|
|
|
|
|
selector.append(ops[token[0]](tokens, token))
|
|
|
|
|
except StopIteration:
|
|
|
|
|
raise SyntaxError("invalid path")
|
|
|
|
|
_cache[path] = selector
|
|
|
|
|
# execute selector pattern
|
|
|
|
|
result = [elem]
|
|
|
|
|
context = _SelectorContext(elem)
|
|
|
|
|
for select in selector:
|
|
|
|
|
result = select(context, result)
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
# end of code based on CPython 2.7 source
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
compat_xpath = lambda xpath: xpath
|
|
|
|
|
|
dirkf
6 months ago