Encode text with the encoding and error handling currently active and return the resulting byte string.

Encode test as text data. text must be a str object. The publisher will apply the configured encoding, error handling and the current text filter (which escapes characters that can't appear in text data (like < etc.)) and returns the resulting str object.

Pushes a new text filter function ontp the text filter stack. This function is responsible for escaping characters that can't appear in text data (like <)). This is used to switch on escaping of " inside attribute values.

Pops the current text filter function from the stack.

Pushes a new error handling scheme onto the error handling stack.

Pop the current error handling scheme from the error handling stack.

Return the encoding currently in effect.

Return (and register) a namespace prefix for the namespace name xmlns. This honors the namespace configuration from self.prefixes and self.prefixdefault. Furthermore the same prefix will be returned from now on (except when the empty prefix becomes invalid once global attributes are encountered)

Get and register a namespace prefix for the namespace object lives in (specified by the xmlns attribute of object). Similar to getnamespaceprefix this honors the namespace configuration from self.prefixes and self.prefixdefault (except when a global attribute requires a non-empty prefix).

Output the node node. This method is a generator that will yield the resulting XML byte sequence in fragments.

Return a bytes object in XML format for the XIST node node.

A generator that will produce a serialized string of node.

Return a string for node.

Write node to the file-like object stream (which must provide a write method).

Restore the attributes entercontent, enterattrs, enterattr, enterelementnode, leaveelementnode, enterattrnode and leaveattrnode to their initial value.

return a clone of self. Compared to deepcopy clone will create multiple instances of objects that can be found in the tree more than once. clone can't clone trees that contain cycles.

Return a shallow copy of self.

Return a deep copy of self.

present is used as a central dispatch method for the presenter classes. Normally it is not called by the user, but internally by the presenter. The user should use the appropriate presenter class directly.

Convenience method for calling convert.

conv will automatically set :obj:`converter`.node to self to remember the "document root node" for which conv has been called, this means that you should not call conv in any of the recursive calls, as you would loose this information. Call convert directly instead.

implementation of the conversion method. When you define your own element classes you have to overwrite this method and implement the desired conversion.

This method must return an instance of Node. It may not change self.

Convert the character content of self to an float. decimal specifies which decimal separator is used in the value (e.g. "." (the default) or ","). ignore specifies which characters will be ignored.

This method will be called by the parser parser once after self is created by the parser (This is used e.g. by URLAttr to incorporate the base URL into the attribute).

event is the parser event that initiated the call.

This method will be called when parsing or publishing to check whether :var`self` is valid.

If self is found to be invalid a warning should be issued through the Python warning framework.

Generate unicode strings for the node. publisher must be an instance of ll.xist.xsc.Publisher.

The encoding and xhtml specification are taken from the publisher.

A generator that will produce this node as a serialized byte string. (i.e. it will output what the method bytes outputs, but incremetally).

For the possible parameters see the ll.xist.xsc.Publisher constructor.

Return self as a serialized bytes object.

For the possible parameters see the ll.xist.xsc.Publisher constructor.

For example:

>>> from ll.xist.ns import html
>>> e = html.div(
...    html.h1("The header"),
...    html.p("The content", class_="content")
... )
>>> print(e.bytes())
b'<div><h1>The header</h1><p class="content">The content</p></div>'

A generator that will produce a serialized string of self (i.e. it will output what the method string outputs, but incremetally).

For the possible parameters see the ll.xist.xsc.Publisher constructor.

Return a serialized (unicode) string for self.

For the possible parameters see the ll.xist.xsc.Publisher constructor.

For example:

>>> from ll.xist.ns import html
>>> e = html.div(
...    html.h1("The header"),
...    html.p("The content", class_="content")
... )
>>> print(e.string())
<div><h1>The header</h1><p class="content">The content</p></div>

Write self to the file-like object stream (which must provide a write method).

For the rest of the parameters see the ll.xist.xsc.Publisher constructor.

Return an iterator for traversing the tree rooted at self.

Each item produced by the iterator is a Cursor object. It contains information about the state of the traversal and can be used to influence which parts of the tree are traversed and in which order.

selectors is used for filtering which nodes to return from the iterator. The arguments entercontent, enterattrs, enterattr, enterelementnode, leaveelementnode, enterattrnode and leaveattrnode specify how the tree should be traversed. For more information see the Cursor class.

Note that the Cursor object is reused by walk, so you can't rely on any attributes remaining the same across calls to next.

The following example shows how to extract the text of an HTML label element for an input element with a specified HTML id:

from ll import misc
from ll.xist import xsc, xfind
from ll.xist.ns import html

def label(doc, id):
   label = misc.first(doc.walk(xfind.attrhasvalue("for", id)), None)
   if label is None:
      return None
   texts = []
   for c in label.node.walk(html.textarea, xsc.Text):
      if isinstance(c.node, html.textarea):
         c.entercontent = False
      else:
         texts.append(str(c.node))
   return " ".join("".join(texts).split()).strip()

doc = html.div(
   html.p(
      html.label(
         "Input your text here: ",
         html.textarea("Default value", rows=20, cols=80, id="foo"),
         " (just a test)",
         for_="foo",
      )
   )
)

print(repr(label(doc, "foo")))

This will output:

'Input your text here: (just a test)'

Return an iterator for traversing the tree. The arguments have the same meaning as those for walk. The items produced by the iterator are the nodes themselves.

Return an iterator for traversing the tree. The arguments have the same meaning as those for walk. The items produced by the iterator are copies of the path.

Return a version of self, where textnodes or character references that contain only linefeeds are removed, i.e. potentially useless whitespace is removed.

Return the node mapped through the function function. This call works recursively (for Frag and Element).

When you want an unmodified node you simply can return self. mapped will make a copy of it and fill the content recursively. Note that element attributes will not be mapped. When you return a different node from function this node will be incorporated into the result as-is.

Return a normalized version of self, which means that consecutive Text nodes are merged.

Return a prettyfied version of self, i.e. one with properly nested and indented tags (as far as possible). If an element has mixed content (i.e. Text and non-Text nodes) the content will be returned as is.

Note that whitespace will prevent pretty printing too, so you might want to call normalized and compact before calling pretty to remove whitespace.

Make self empty.

Append every item in others to self.

Append all items from the sequence items to self.

Insert all items in others at the position index. (this is the same as self[index:index] = others)

Return a version of self with a separator node between the nodes of self.

if clone is false, one node will be inserted several times, if clone is true, clones of this node will be used.

Return a reversed version of the self.

Return a filtered version of the self, i.e. a copy of self, where only content nodes for which function returns true will be copied.

Return a shuffled version of self, i.e. a copy of self where the content nodes are randomly reshuffled.

Return whether self contains nodes other than Text.

Check whether self has an allowed value, i.e. one that is specified in the class attribute values. If the value is not allowed a warning will be issued through the Python warning framework.

If self is "fancy" (i.e. contains non-Text nodes), no check will be done.

Replace each URL in the style. Each URL will be passed to the callable replacer and replaced with the returned value.

Return a list of all the URLs (as URL objects) found in the style attribute.

Return self as a URL object (note that non-Text content will be filtered out).

return a URL pointing to the real location of the referenced resource. root must be the root URL relative to which self will be interpreted and usually comes from the root attribute of the converter argument in convert.

Return the size of an image as a tuple.

Return the size of a file in bytes.

returns the timestamp for the last modification to the file

Return a Resource for reading from the URL.

Return a Resource for writing to the URL.

Works like the dictionary method get, it returns the attribute with the XML name name, or default if self has no such attribute. name may also be an attribute class (either from self.Attrs or a global attribute).

Works like the dictionary method setdefault, it returns the attribute with the Python name name. If self has no such attribute, it will be set to default and default will be returned as the new attribute value.

Copies attributes over from all mappings in args and from kwargs. Keywords are treated as the Python names of attributes.

Return a filtered version of self.

Return a copy of self where only the attributes with XML names in names are kept, all others are removed.

Return a copy of self where all the attributes with XML names in names are removed.

Append every item in items to the elements content.

Append all items in items to the elements content.

Insert every item in items at the position index.

Return a version of self with a separator node between the child nodes of self. For more info see Frag.withsep.

Return a reversed version of self.

Return a filtered version of the self.

Return a shuffled version of the self.

Publish self to the publisher publisher (outside of any attribute)

Publish the attribute attr to the publisher publisher.

Publish the boolean attribute attr to the publisher

Register object in the pool. object can be:

• a Element, ProcInst or Entity class;

• an Attr class for a global attribute;

• an Attrs class containing global attributes;

• a dict (all values will be registered, this makes it possible to e.g. register all local variables by passing vars());

• a module (all attributes in the module will be registered).

Make self empty.

Return a copy of self.

Return an iterator for all registered element classes.

Return the element class for the element with the XML name name and the namespace xmlns. If the element can't be found an Element will be returned.

Return an element object for the element type with the XML name name and the namespace xmlns.

Is there a registered element class in self for the element type with the Python name name and the namespace xmlns?

Return an iterator for all registered processing instruction classes.

Return the processing instruction class for the PI with the target name name. If the processing instruction can't be found an return ProcInst.

Return a processing instruction object for the PI type with the target name name.

Is there a registered processing instruction class in self for the PI with the target name name?

Return an iterator for all registered entity classes.

Return the entity class for the entity with the XML name name. If the entity can't be found return Entity.

Return an entity object for the entity with the XML name name.

Is there a registered entity class in self for the entity with the XML name name?

Return the key that can be used to set the attribute with the name name and the namespace xmlns. If self (or one of the base pools) has any global attribute registered for that name/namespace, the attribute class will be returned. Otherwise the tuple (name, xmlns) (or name itself for a local attribute) will be returned. With this key Attrs.__setitem__ will create the appropriate attribute class.

Create a text node with the content content.

Create a comment node with the content content.

Return a location where the line number is incremented by offset (and the column number is reset to 0).