This module contains XFind selectors and related classes and functions.

A selector specifies a condition that a node in an XIST tree must satisfy to match the selector. For example the method Node.walk will only output nodes that match the specified selector.

Selectors can be combined with various operations and form a language comparable to XPath but implemented as Python expressions.

def `filter`(`iter`, *`selectors`):

Filter an iterator over xsc.Cursor objects against a Selector object.

Example:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> [c.node.string() for c in xfind.filter(doc.walk(), html.b, html.title)]
[
   '<title>Welcome to Python.org</title>',
   '<b>Web Programming</b>',
   '<b>GUI Development</b>',
   '<b>Scientific and Numeric</b>',
   '<b>Software Development</b>',
   '<b>System Administration</b>'
]

def `selector`(*`objs`):

Create a Selector object from objs.

If objs is empty (i.e. selector is called without arguments) any is returned (which matches every node).

If more than one argument is passed (or the argument is a tuple), an OrCombinator is returned.

Otherwise the following steps are taken for the single argument obj:

if obj already is a Selector object it is returned unchanged;
if obj is a Node subclass, an IsInstanceSelector is returned (which matches if the node is an instance of this class);
if obj is a Node instance, an IsSelector is returned (which matches only obj);
if obj is callable a CallableSelector is returned (where matching is done by calling obj);
if obj is None any will be returned;
otherwise selector will raise a TypeError.

class `Selector`(`object`):

A selector specifies a condition that a node in an XIST tree must satisfy to match the selector.

Whether a node matches the selector can be specified by overwriting the __contains__ method. Selectors can be combined with various operations (see methods below).

def `contains`(`self`, *`args`, **`kwargs`):

Return whether path (which is a list of XIST nodes from the root of the tree to the node in question) matches the selector.

def `truediv`(`self`, `other`):

Create a ChildCombinator with self as the left hand selector and other as the right hand selector.

def `floordiv`(`self`, `other`):

Create a DescendantCombinator with self as the left hand selector and other as the right hand selector.

def `mul`(`self`, `other`):

Create an AdjacentSiblingCombinator with self as the left hand selector and other as the right hand selector.

def `pow`(`self`, `other`):

Create a GeneralSiblingCombinator with self as the left hand selector and other as the right hand selector.

def `and`(`self`, `other`):

Create an AndCombinator from self and other.

def `or`(`self`, `other`):

Create an OrCombinator from self and other.

def `invert`(`self`):

Create a NotCombinator inverting self.

class `AnySelector`(`Selector`):

Selector that selects all nodes.

An instance of this class named any is created as a module global, i.e. you can use xfind.any.

def `contains`(`self`, `path`):

def `and`(`self`, `other`):

def `or`(`self`, `other`):

class `IsInstanceSelector`(`Selector`):

Selector that selects all nodes that are instances of the specified type. You can either create an IsInstanceSelector object directly or simply pass a class to a function that expects a selector (this class will be automatically wrapped in an IsInstanceSelector):

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.a):
...   print(node.attrs.href, node.attrs.title)
...
https://www.python.org/#content Skip to content
https://www.python.org/#python-network
https://www.python.org/ The Python Programming Language
https://www.python.org/psf-landing/ The Python Software Foundation
...

def `init`(`self`, *`types`):

def `contains`(`self`, `path`):

def `or`(`self`, `other`):

def `getitem`(`self`, `index`):

Return an nthoftype selector that uses index as the index and self.types as the types.

def `str`(`self`):

class `element`(`Selector`):

Selector that selects all elements that have a specified namespace name and element name:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.element(html, "img")):
...   print(node.string())
...
<img alt="python™" class="python-logo" src="https://www.python.org/static/img/python-logo.png" />

def `init`(`self`, `xmlns`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `procinst`(`Selector`):

Selector that selects all processing instructions that have a specified name.

def `init`(`self`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `entity`(`Selector`):

Selector that selects all entities that have a specified name.

def `init`(`self`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `IsSelector`(`Selector`):

Selector that selects one specific node in the tree. This can be combined with other selectors via ChildCombinator or DescendantCombinator selectors to select children of this specific node. You can either create an IsSelector directly or simply pass a node to a function that expects a selector:

>>> from ll.xist import xsc, parse
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(doc[0]/xsc.Element):
...   print(repr(node))
...
<element ll.xist.ns.html.head xmlns='http://www.w3.org/1999/xhtml' (89 children/no attrs) location='https://www.python.org/:?:?' at 0x104ad7630>
<element ll.xist.ns.html.body xmlns='http://www.w3.org/1999/xhtml' (14 children/2 attrs) location='https://www.python.org/:?:?' at 0x104cc1f28>

def `init`(`self`, `node`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `IsRootSelector`(`Selector`):

Selector that selects the node that is the root of the traversal.

An instance of this class named isroot is created as a module global, i.e. you can use xfind.isroot.

def `contains`(`self`, `path`):

class `IsEmptySelector`(`Selector`):

Selector that selects all empty elements or fragments.

An instance of this class named empty is created as a module global, i.e. you can use xfind.empty:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.empty):
...   print(node.string())
...
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<link href="https://ajax.googleapis.com/" rel="prefetch" />
<meta name="application-name" content="Python.org" />
...

def `contains`(`self`, `path`):

class `OnlyChildSelector`(`Selector`):

Selector that selects all nodes that are the only child of their parents.

An instance of this class named onlychild is created as a module global, i.e. you can use xfind.onlychild:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.onlychild & html.a):
...   print(node.string())
...
<a class="text-shrink" href="javascript:;" title="Make Text Smaller">Smaller</a>
<a class="text-grow" href="javascript:;" title="Make Text Larger">Larger</a>
<a class="text-reset" href="javascript:;" title="Reset any font size changes I have made">Reset</a>
<a href="http://plus.google.com/+Python"><span aria-hidden="true" class="icon-google-plus"></span>Google+</a>
...

def `contains`(`self`, `path`):

def `str`(`self`):

class `OnlyOfTypeSelector`(`Selector`):

Selector that selects all nodes that are the only nodes of their type among their siblings.

An instance of this class named onlyoftype is created as a module global, i.e. you can use xfind.onlyoftype:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.onlyoftype & xsc.Element):
...   print(repr(node))
...
<element ll.xist.ns.html.html xmlns='http://www.w3.org/1999/xhtml' (7 children/3 attrs) location='https://www.python.org/:?:?' at 0x108858d30>
<element ll.xist.ns.html.head xmlns='http://www.w3.org/1999/xhtml' (89 children/no attrs) location='https://www.python.org/:?:?' at 0x108858630>
<element ll.xist.ns.html.title xmlns='http://www.w3.org/1999/xhtml' (1 child/no attrs) location='https://www.python.org/:?:?' at 0x108c547b8>
<element ll.xist.ns.html.body xmlns='http://www.w3.org/1999/xhtml' (14 children/2 attrs) location='https://www.python.org/:?:?' at 0x108c54eb8>
...

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasattr`(`Selector`):

Selector that selects all element nodes that have an attribute with one of the specified names. (Names can be strings, (attribute name, namespace name) tuples or attribute classes or instances):

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.hasattr("id")):
...   print(node.xmlname, node.attrs.id)
...
body homepage
div touchnav-wrapper
div top
a close-python-network
...

def `init`(`self`, *`attrnames`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrhasvalue`(`Selector`):

Selector that selects all element nodes where an attribute with the specified name has one of the specified values. (Names can be strings, (attribute name, namespace name) tuples or attribute classes or instances). Note that "fancy" attributes (i.e. those containing non-text) will not be considered:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.attrhasvalue("rel", "stylesheet")):
...   print(node.attrs.href)
...
https://www.python.org/static/stylesheets/style.css
https://www.python.org/static/stylesheets/mq.css

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrcontains`(`Selector`):

Selector that selects all element nodes where an attribute with the specified name contains one of the specified substrings in its value. (Names can be strings, (attribute name, namespace name) tuples or attribute classes or instances). Note that "fancy" attributes (i.e. those containing non-text) will not be considered:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.attrcontains("rel", "stylesheet")):
...   print(node.attrs.rel, node.attrs.href)
...
stylesheet https://www.python.org/static/stylesheets/style.css
stylesheet https://www.python.org/static/stylesheets/mq.css

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrstartswith`(`Selector`):

Selector that selects all element nodes where an attribute with the specified name starts with any of the specified strings. (Names can be strings, (attribute name, namespace name) tuples or attribute classes or instances). Note that "fancy" attributes (i.e. those containing non-text) will not be considered:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.attrstartswith("class", "icon-")):
...   print(node.string())
...
<span aria-hidden="true" class="icon-arrow-down"><span>▼</span></span>
<span aria-hidden="true" class="icon-arrow-up"><span>▲</span></span>
<span aria-hidden="true" class="icon-search"></span>
<span aria-hidden="true" class="icon-google-plus"></span>
...

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrendswith`(`Selector`):

Selector that selects all element nodes where an attribute with the specified name ends with one of the specified strings. (Names can be strings, (attribute name, namespace name) tuples or attribute classes or instances). Note that "fancy" attributes (i.e. those containing non-text) will not be considered:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.attrendswith("href", ".css")):
...   print(node.attrs.href)
...
https://www.python.org/static/stylesheets/style.css
https://www.python.org/static/stylesheets/mq.css

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasid`(`Selector`):

Selector that selects all element nodes where the id attribute has one if the specified values:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.hasid("id-search-field")):
...   print(node.string())
...
<input class="search-field" id="id-search-field" name="q" placeholder="Search" role="textbox" tabindex="1" type="search" />

def `init`(`self`, *`ids`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasclass`(`Selector`):

Selector that selects all element nodes where the class attribute contains one of the specified values:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.hasclass("tier-1")/html.a):
...   print(node.string())
...
A A
Socialize
Sign In
About
Downloads
...

def `init`(`self`, *`classnames`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `InAttrSelector`(`Selector`):

Selector that selects all attribute nodes and nodes inside of attributes:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.inattr & xsc.Text, enterattrs=True, enterattr=True):
...   print(path[-3].xmlname, path[-2].xmlname, path[-1].string())
...
html class no-js
html dir ltr
html lang en
meta charset utf-8
meta content IE=edge
meta http-equiv X-UA-Compatible
...

def `contains`(`self`, `path`):

def `str`(`self`):

class `Combinator`(`Selector`):

A Combinator is a selector that transforms one or combines two or more other selectors in a certain way.

class `BinaryCombinator`(`Combinator`):

A BinaryCombinator is a combinator that combines two selector: the left hand selector and the right hand selector.

def `init`(`self`, `left`, `right`):

def `str`(`self`):

class `ChildCombinator`(`BinaryCombinator`):

A ChildCombinator is a BinaryCombinator. To match the ChildCombinator the node must match the right hand selector and its immediate parent must match the left hand selector (i.e. it works similar to the > combinator in CSS or the / combinator in XPath).

ChildCombinator objects can be created via the division operator (/):

>>> from ll.xist import xsc, parse
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.a/html.img):
...   print(node.string())
...
<img alt="python™" class="python-logo" src="https://www.python.org/static/img/python-logo.png" />

def `contains`(`self`, `path`):

class `DescendantCombinator`(`BinaryCombinator`):

A DescendantCombinator is a BinaryCombinator. To match the DescendantCombinator the node must match the right hand selector and any of its ancestor nodes must match the left hand selector (i.e. it works similar to the descendant combinator in CSS or the // combinator in XPath).

DescendantCombinator objects can be created via the floor division operator (//):

>>> from ll.xist import xsc, parse
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.div//html.img):
...   print(node.string())
...
<img alt="python™" class="python-logo" src="https://www.python.org/static/img/python-logo.png" />

def `contains`(`self`, `path`):

class `AdjacentSiblingCombinator`(`BinaryCombinator`):

A AdjacentSiblingCombinator is a BinaryCombinator. To match the AdjacentSiblingCombinator the node must match the right hand selector and the immediately preceding sibling must match the left hand selector.

AdjacentSiblingCombinator objects can be created via the multiplication operator (*). The following example outputs all span elements that immediately follow a form element:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.form*html.span):
...   print(node.string())
...
<span class="breaker"></span>

def `contains`(`self`, `path`):

class `GeneralSiblingCombinator`(`BinaryCombinator`):

A GeneralSiblingCombinator is a BinaryCombinator. To match the GeneralSiblingCombinator the node must match the right hand selector and any of the preceding siblings must match the left hand selector.

AdjacentSiblingCombinator objects can be created via the exponentiation operator (**). The following example outputs all meta element that come after the link elements:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.link**html.meta):
...   print(node.string())
...
<meta name="application-name" content="Python.org" />
<meta name="msapplication-tooltip" content="The official home of the Python Programming Language" />
<meta name="apple-mobile-web-app-title" content="Python.org" />
<meta name="apple-mobile-web-app-capable" content="yes" />
<meta name="apple-mobile-web-app-status-bar-style" content="black" />
...

def `contains`(`self`, `path`):

class `ChainedCombinator`(`Combinator`):

A ChainedCombinator combines any number of other selectors.

def `init`(`self`, *`selectors`):

def `str`(`self`):

class `OrCombinator`(`ChainedCombinator`):

An OrCombinator is a ChainedCombinator where the node must match at least one of the selectors to match the OrCombinator. An OrCombinator can be created with the binary or operator (|):

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.hasattr("href") | xfind.hasattr("src")):
...   print(node.attrs.href if "href" in node.Attrs else node.attrs.src)
...
https://ajax.googleapis.com/
https://www.python.org/static/js/libs/modernizr.js
https://www.python.org/static/stylesheets/style.css
https://www.python.org/static/stylesheets/mq.css
https://www.python.org/static/favicon.ico
...

def `contains`(`self`, `path`):

def `or`(`self`, `other`):

class `AndCombinator`(`ChainedCombinator`):

An AndCombinator is a ChainedCombinator where the node must match all of the combined selectors to match the AndCombinator. An AndCombinator can be created with the binary and operator (&):

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.input & xfind.hasattr("id")):
...   print(node.string())
...
<input class="search-field" id="id-search-field" name="q" placeholder="Search" role="textbox" tabindex="1" type="search" />

def `contains`(`self`, `path`):

def `and`(`self`, `other`):

class `NotCombinator`(`Combinator`):

A NotCombinator inverts the selection logic of the underlying selector, i.e. a node matches only if it does not match the underlying selector. A NotCombinator can be created with the unary inversion operator (~).

The following example outputs all internal scripts:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(html.script & ~xfind.hasattr("src")):
...   print(node.string())
...
<script type="text/javascript">
    var _gaq = _gaq || [];
    _gaq.push(['_setAccount', 'UA-39055973-1']);
    _gaq.push(['_trackPageview']);

    (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
    })();
    </script>
<script>window.jQuery || document.write('&lt;script src="/static/js/libs/jquery-1.8.2.min.js"&gt;&lt;\/script&gt;')</script>

def `init`(`self`, `selector`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `CallableSelector`(`Selector`):

A CallableSelector is a selector that calls a user specified callable to select nodes. The callable gets passed the path and must return a bool specifying whether this path is selected. A CallableSelector is created implicitely whenever a callable is passed to a method that expects a selector.

The following example outputs all links that point outside the python.org domain:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> def isextlink(path):
...   return isinstance(path[-1], html.a) and not str(path[-1].attrs.href).startswith("https://www.python.org")
...
>>> for node in doc.walknodes(isextlink):
...   print(node.string())
...
<a href="http://docs.python.org/" title="Python Documentation">Docs</a>
<a href="https://pypi.python.org/" title="Python Package Index">PyPI</a>
<a class="text-shrink" href="javascript:;" title="Make Text Smaller">Smaller</a>
<a class="text-grow" href="javascript:;" title="Make Text Larger">Larger</a>
..

def `init`(`self`, `func`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `nthchild`(`Selector`):

An nthchild object is a selector that selects every node that is the n-th child of its parent. E.g. nthchild(0) selects every first child, nthchild(-1) selects each last child. Furthermore nthchild("even") selects each first, third, fifth, ... child and nthchild("odd") selects each second, fourth, sixth, ... child.

def `init`(`self`, `index`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `nthoftype`(`Selector`):

An nthoftype object is a selector that selects every node that is the n-th node of a specified type among its siblings. Similar to nthchild nthoftype supports negative and positive indices as well as "even" and "odd". Which types are checked can be passed explicitly. If no types are passed the type of the node itself is used:

>>> from ll.xist import xsc, parse, xfind
>>> from ll.xist.ns import xml, html, chars
>>> doc = parse.tree(
...   parse.URL("https://www.python.org/"),
...   parse.Tidy(),
...   parse.NS(html),
...   parse.Node(pool=xsc.Pool(xml, html, chars))
... )
>>> for node in doc.walknodes(xfind.nthoftype(0, html.h2)):
...   print(node.string())
...
<h2 class="widget-title"><span aria-hidden="true" class="icon-get-started"></span>Get Started</h2>
<h2 class="widget-title"><span aria-hidden="true" class="icon-download"></span>Download</h2>
<h2 class="widget-title"><span aria-hidden="true" class="icon-documentation"></span>Docs</h2>
<h2 class="widget-title"><span aria-hidden="true" class="icon-jobs"></span>Jobs</h2>
...

def filter​(iter, *selectors):

def selector​(*objs):

class Selector​(object):

def __contains__​(self, *args, **kwargs):

def __truediv__​(self, other):

def __floordiv__​(self, other):

def __mul__​(self, other):

def __pow__​(self, other):

def __and__​(self, other):

def __or__​(self, other):

def __invert__​(self):

class AnySelector​(Selector):

def __contains__​(self, path):

def __and__​(self, other):

def __or__​(self, other):

class IsInstanceSelector​(Selector):

def __init__​(self, *types):

def __contains__​(self, path):

def __or__​(self, other):

def __getitem__​(self, index):

def __str__​(self):

class element​(Selector):

def __init__​(self, xmlns, xmlname):

def __contains__​(self, path):

def __str__​(self):

class procinst​(Selector):

def __init__​(self, xmlname):

def __contains__​(self, path):

def __str__​(self):

class entity​(Selector):

def __init__​(self, xmlname):

def __contains__​(self, path):

def __str__​(self):

class IsSelector​(Selector):

def __init__​(self, node):

def __contains__​(self, path):

def __str__​(self):

class IsRootSelector​(Selector):

def __contains__​(self, path):

class IsEmptySelector​(Selector):

def __contains__​(self, path):

class OnlyChildSelector​(Selector):

def __contains__​(self, path):

def __str__​(self):

class OnlyOfTypeSelector​(Selector):

def __contains__​(self, path):

def __str__​(self):

class hasattr​(Selector):

def __init__​(self, *attrnames):

def __contains__​(self, path):

def __str__​(self):

class attrhasvalue​(Selector):

def __init__​(self, attrname, *attrvalues):

def __contains__​(self, path):

def __str__​(self):

class attrcontains​(Selector):

def __init__​(self, attrname, *attrvalues):

def __contains__​(self, path):

def __str__​(self):

class attrstartswith​(Selector):

def __init__​(self, attrname, *attrvalues):

def __contains__​(self, path):

def __str__​(self):

class attrendswith​(Selector):

def __init__​(self, attrname, *attrvalues):

def __contains__​(self, path):

def __str__​(self):

class hasid​(Selector):

def __init__​(self, *ids):

def __contains__​(self, path):

def __str__​(self):

class hasclass​(Selector):

def __init__​(self, *classnames):

def __contains__​(self, path):

def __str__​(self):

class InAttrSelector​(Selector):

def __contains__​(self, path):

def __str__​(self):

class Combinator​(Selector):

class BinaryCombinator​(Combinator):

def `filter`(`iter`, *`selectors`):

def `selector`(*`objs`):

class `Selector`(`object`):

def `contains`(`self`, *`args`, **`kwargs`):

def `truediv`(`self`, `other`):

def `floordiv`(`self`, `other`):

def `mul`(`self`, `other`):

def `pow`(`self`, `other`):

def `and`(`self`, `other`):

def `or`(`self`, `other`):

def `invert`(`self`):

class `AnySelector`(`Selector`):

def `contains`(`self`, `path`):

def `and`(`self`, `other`):

def `or`(`self`, `other`):

class `IsInstanceSelector`(`Selector`):

def `init`(`self`, *`types`):

def `contains`(`self`, `path`):

def `or`(`self`, `other`):

def `getitem`(`self`, `index`):

def `str`(`self`):

class `element`(`Selector`):

def `init`(`self`, `xmlns`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `procinst`(`Selector`):

def `init`(`self`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `entity`(`Selector`):

def `init`(`self`, `xmlname`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `IsSelector`(`Selector`):

def `init`(`self`, `node`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `IsRootSelector`(`Selector`):

def `contains`(`self`, `path`):

class `IsEmptySelector`(`Selector`):

def `contains`(`self`, `path`):

class `OnlyChildSelector`(`Selector`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `OnlyOfTypeSelector`(`Selector`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasattr`(`Selector`):

def `init`(`self`, *`attrnames`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrhasvalue`(`Selector`):

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrcontains`(`Selector`):

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrstartswith`(`Selector`):

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `attrendswith`(`Selector`):

def `init`(`self`, `attrname`, *`attrvalues`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasid`(`Selector`):

def `init`(`self`, *`ids`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `hasclass`(`Selector`):

def `init`(`self`, *`classnames`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `InAttrSelector`(`Selector`):

def `contains`(`self`, `path`):

def `str`(`self`):

class `Combinator`(`Selector`):

class `BinaryCombinator`(`Combinator`):