lxml.etree.PythonElementClassLookup

Package lxml :: Module etree :: Class PythonElementClassLookup |
[hide private]
[frames] | no frames]

# Class PythonElementClassLookup

                object --+
                         |
        ElementClassLookup --+
                             |
    FallbackElementClassLookup --+
                                 |
                                PythonElementClassLookup

PythonElementClassLookup(self, fallback=None) Element class lookup based on a subclass method.

This class lookup scheme allows access to the entire XML tree in read-only mode. To use it, re-implement the `lookup(self, doc, root)` method in a subclass:

    from lxml import etree, pyclasslookup

    class MyElementClass(etree.ElementBase):
        honkey = True

    class MyLookup(pyclasslookup.PythonElementClassLookup):
        def lookup(self, doc, root):
            if root.tag == "sometag":
                return MyElementClass
            else:
                for child in root:
                    if child.tag == "someothertag":
                        return MyElementClass
            # delegate to default
            return None

If you return None from this method, the fallback will be called.

The first argument is the opaque document instance that contains the Element. The second argument is a lightweight Element proxy implementation that is only valid during the lookup. Do not try to keep a reference to it. Once the lookup is done, the proxy will be invalid.

Also, you cannot wrap such a read-only Element in an ElementTree, and you must take care not to keep a reference to them outside of the lookup() method.

Note that the API of the Element objects is not complete. It is purely read-only and does not support all features of the normal lxml.etree API (such as XPath, extended slicing or some iteration methods).

See http://codespeak.net/lxml/element_classes.html

Instance Methods | [hide private]
a new object with type S, a subtype of T |
__new__(T, S, ...) |
lookup(self, doc, element) Override this method to implement your own lookup scheme. |
Inherited from `FallbackElementClassLookup`: `__init__`, `set_fallback` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__reduce__`, `__reduce_ex__`, `__repr__`, `__setattr__`, `__sizeof__`, `__str__`, `__subclasshook__`

Properties | [hide private]
Inherited from `FallbackElementClassLookup`: `fallback` Inherited from `object`: `__class__`

Method Details | [hide private]

### __new__(T, S, ...) |
Returns: a new object with type S, a subtype of T Overrides: object.__new__