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
projects / youtube-dl / commitdiff