lxml

https://lxml.de
Admin
lxml is a Pythonic binding for libxml2 and libxslt that provides a fast, feature-rich library for...
Tokens:399,419
Snippets:4,050
Trust Score:9.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Cython module setup for lxml.etree C-API

Source: https://lxml.de/capi.html

Starts a Cython extension module that uses the public C-API of lxml.etree. Includes a distutils directive to point the compiler to lxml header files, cimports the public functions, imports the Python module, and initializes the C-API access.

```cython
# My Cython extension

# directive pointing compiler to lxml header files;
# use ``aliases={"LXML_PACKAGE_DIR": lxml.__path__}``
# argument to cythonize in setup.py to dynamically
# determine dir at compile time
# distutils: include_dirs = LXML_PACKAGE_DIR

# import the public functions and classes of lxml.etree
cimport lxml.includes.etreepublic as cetree

# import the lxml.etree module in Python
cdef object etree
from lxml import etree

# initialize the access to the C-API of lxml.etree
cetree.import_lxml__etree()

```

--------------------------------

### Install lxml system-wide with static dependencies

Source: https://lxml.de/build.html

Installs lxml into the system Python package directory with static dependencies using sudo.

```bash
STATIC_DEPS=true sudo pip install lxml


```

--------------------------------

### Build Windows Installer with Static Dependencies

Source: https://lxml.de/build.html

Build a Windows installer for lxml with statically linked libxml2 and libxslt dependencies. The --static-deps flag downloads pre-built packages of the dependencies and builds statically. The resulting installer is placed in the 'pkg' directory.

```bash
python setup.py bdist_wininst --static-deps
```

--------------------------------

### Install lxml globally with sudo

Source: https://lxml.de/installation.html

Install lxml globally on Linux or other systems where admin rights are needed for a system-wide installation.

```bash
sudo pip install lxml

```

--------------------------------

### Build Debian Package and Install

Source: https://lxml.de/build.html

Steps for building Debian packages from lxml SVN sources. The commands shown are: run dpkg-buildpackage to build the package, install missing dependencies with apt-get build-dep if needed, and install the resulting .deb packages with dpkg -i.

```bash
dpkg-buildpackage -rfakeroot -us -uc
```

```bash
apt-get build-dep lxml
```

```bash
dpkg -i
```

--------------------------------

### Install python3-lxml via apt-get on Debian/Ubuntu

Source: https://lxml.de/installation.html

Quickest way to install the packaged lxml on Debian/Ubuntu using the system package manager.

```bash
sudo apt-get install python3-lxml

```

--------------------------------

### Build with custom dependency versions and install

Source: https://lxml.de/build.html

Builds lxml with specific versions of libxml2 and libxslt, using tar.gz files placed in the 'libs' subdirectory, then installs the package with sudo.

```bash
python setup.py build --static-deps \
       --libxml2-version=2.9.12 \
       --libxslt-version=1.1.34 \

sudo python setup.py install


```

--------------------------------

### Basic usage of etree.XMLPullParser with events

Source: https://lxml.de/parsing.html

Shows how to create an XMLPullParser with start and end events, feed it chunks of XML, and iterate over parse events using read_events(). The example demonstrates that events are only available after feeding data and that the iterator can be called again to get new events.

```python
>>> parser = etree.XMLPullParser(events=('start', 'end'))

>>> def print_events(parser):
...     for action, element in parser.read_events():
...         print('%s: %s' % (action, element.tag))

>>> parser.feed('<root>some text')
>>> print_events(parser)
start: root
>>> print_events(parser)    # well, no more events, as before ...

>>> parser.feed('<child><a />')
>>> print_events(parser)
start: child
start: a
end: a

>>> parser.feed('</child></roo')
>>> print_events(parser)
end: child
>>> parser.feed('t>')
>>> print_events(parser)
end: root

```

--------------------------------

### Build lxml with setup.py build or bdist_egg

Source: https://lxml.de/build.html

Build the lxml package from source. The first command performs a standard build. The second creates an egg distribution and requires 'setuptools' or 'distribute'.

```text
python setup.py build
```

```text
python setup.py bdist_egg     # requires 'setuptools' or 'distribute'
```

--------------------------------

### iterparse with tag argument

Source: https://lxml.de/parsing.html

Uses the tag argument to filter events to only those for elements with the tag 'element'. This is part of the iterwalk example setup.

```python
>>> f = StringIO(xml)
>>> context = etree.iterparse(
...             f, events=("start", "end"), tag="element")

>>> for action, elem in context:
...     print("%s: %s" % (action, elem.tag))
start: element
end: element
start: element
end: element

>>> root = context.root
```

--------------------------------

### Build lxml wheel with python setup.py bdist_wheel

Source: https://lxml.de/build.html

Builds a wheel from the lxml release archive. Assumes setuptools/distribute and wheel are installed. The resulting .whl is written to the `dist` directory.

```bash
python setup.py bdist_wheel

```

--------------------------------

### Get root element from parsed tree

Source: https://lxml.de/tutorial.html

After parsing with parse(), use tree.getroot() to obtain the root Element. The example prints the tag and serializes the root.

```python
>>> root = tree.getroot()
>>> print(root.tag)
root
>>> etree.tostring(root)
b'<root>data</root>'
```

--------------------------------

### Get DTD element declarations as a list with elements

Source: https://lxml.de/validation.html

The elements method returns the element declarations as a list. The example shows the length of the list for a DTD with two element declarations.

```python
>>> dtd = etree.DTD(StringIO('<!ELEMENT a EMPTY><!ELEMENT b EMPTY>'))
>>> len(dtd.elements())
2

```

--------------------------------

### Build lxml extension modules with python setup.py build

Source: https://lxml.de/build.html

Builds the lxml extension modules. On Unix-like platforms, this is the first step before stripping .so files to reduce distribution size.

```bash
python setup.py build

```

--------------------------------

### XMLPullParser(event_types) - Comments and PIs

Source: https://lxml.de/parsing.html

Creates an XMLPullParser that supports 'comment' and 'pi' event types in addition to 'start' and 'end'. The example demonstrates parsing a document with comments and processing instructions.

```APIDOC
## XMLPullParser(event_types) - Comments and PIs

### Description
Creates an XMLPullParser that supports 'comment' and 'pi' event types in addition to 'start' and 'end'. The example demonstrates parsing a document with comments and processing instructions.

### Method
Constructor

### Endpoint
etree.XMLPullParser(event_types)

### Parameters
#### Constructor Parameters
- **event_types** (tuple of strings) - Required - The event types to listen for, including "start", "end", "comment", and "pi".

### Request Example
```python
event_types = ("start", "end", "comment", "pi")
parser = etree.XMLPullParser(event_types)
parser.feed('<?some pi ?><!-- a comment --><root>')
parser.feed('<element key="value">text</element>')
parser.feed('<!-- another comment -->')
parser.feed('<element>text</element>tail')
parser.feed('<empty-element xmlns="http://testns/" />')
parser.feed('</root>')
for action, elem in parser.read_events():
    if action in ('start', 'end'):
        print("%s: %s" % (action, elem.tag))
    elif action == 'pi':
        print("%s: -%s=%s-" % (action, elem.target, elem.text))
    else: # 'comment'
        print("%s: -%s-" % (action, elem.text))
```

### Response
#### Success Response
- **action** (string) - The event type: "start", "end", "comment", or "pi".
- **elem.tag** (string) - The tag of the element (for start/end events).
- **elem.target** (string) - The target of the processing instruction (for pi events).
- **elem.text** (string) - The text content (for comment and pi events).

#### Response Example
```
pi: -some=pi -
comment: - a comment -
start: root
start: element
end: element
comment: - another comment -
start: element
end: element
start: {http://testns/}empty-element
end: {http://testns/}empty-element
end: root
```
```

--------------------------------

### Build lxml egg with python setup.py build_egg

Source: https://lxml.de/build.html

Builds an lxml egg file. Assumes setuptools or distribute is installed. The resulting egg is written to the `dist` directory.

```bash
python setup.py build_egg

```

--------------------------------

### Register a resolver with an XMLParser

Source: https://lxml.de/resolvers.html

Resolvers are registered local to a parser. This example creates an XMLParser with load_dtd=True and adds the DTDResolver instance. The default parser does not load DTDs, so this setup is required for the resolver to be called.

```python
>>> parser = etree.XMLParser(load_dtd=True)
>>> parser.resolvers.add( DTDResolver() )

```

--------------------------------

### XMLPullParser(event_types, tag=...) - Namespace Filtering

Source: https://lxml.de/parsing.html

Creates an XMLPullParser with specified event types and a tag filter for namespace wildcards. The example uses event types 'start' and 'end' with a namespace wildcard to capture events for elements in that namespace.

```APIDOC
## XMLPullParser(event_types, tag=...) - Namespace Filtering

### Description
Creates an XMLPullParser with specified event types and a tag filter for namespace wildcards. The example uses event types 'start' and 'end' with a namespace wildcard to capture events for elements in that namespace.

### Method
Constructor

### Endpoint
etree.XMLPullParser(event_types, tag=...)

### Parameters
#### Constructor Parameters
- **event_types** (tuple of strings) - Required - The event types to listen for (e.g., ("start", "end")).
- **tag** (string) - Optional - A tag name or namespace wildcard (e.g., "{http://testns/}*") to filter events.

### Request Example
```python
event_types = ("start", "end")
parser = etree.XMLPullParser(event_types, tag="{http://testns/}*")
parser.feed('<root><element key="value">text</element>')
parser.feed('<element><child /></element>')
parser.feed('<empty-element xmlns="http://testns/" /></root>')
for action, elem in parser.read_events():
    print("%s: %s" % (action, elem.tag))
```

### Response
#### Success Response
- **action** (string) - The event type (e.g., "start" or "end").
- **elem.tag** (string) - The tag of the element.

#### Response Example
```
start: {http://testns/}empty-element
end: {http://testns/}empty-element
```
```

--------------------------------

### Build lxml with static dependencies via setup.py

Source: https://lxml.de/build.html

Builds lxml with static dependencies, downloading and building the latest versions of libxml2 and libxslt from the official FTP site. This is necessary on macOS because Apple ships outdated system libraries that can lead to crashes.

```bash
python setup.py build --static-deps


```

--------------------------------

### Inserting pre-built elements with xmlfile

Source: https://lxml.de/api.html

Demonstrates writing pre-constructed Elements and subtrees into an xmlfile context. Shows a loop that creates elements and writes them, then discards them to reduce memory.

```python
>>> f = BytesIO()
>>> with etree.xmlfile(f) as xf:
...     with xf.element('abc'):
...         with xf.element('in'):
...
...             for value in '123':
...                 # construct a really complex XML tree
...                 el = etree.Element('xyz', attr=value)
...
...                 xf.write(el)
...
...                 # no longer needed, discard it right away!
...                 el = None

>>> print(f.getvalue().decode('utf-8'))
<abc><in><xyz attr="1"/><xyz attr="2"/><xyz attr="3"/></in></abc>

```

--------------------------------

### AttributeFilter TreeBuilder subclass for XMLPullParser

Source: https://lxml.de/parsing.html

Defines an AttributeFilter class that inherits from etree.TreeBuilder and overrides start() to remove an 'evil' attribute from the attrib dict before calling super(). Used with etree.XMLPullParser(target=AttributeFilter()) to filter attributes during parsing. The example feeds XML and reads events, showing that the 'evil' attribute is removed from child2.

```python
>>> class AttributeFilter(etree.TreeBuilder):
...     def start(self, tag, attrib):
...         attrib = dict(attrib)
...         if 'evil' in attrib:
...             del attrib['evil']
...         return super(AttributeFilter, self).start(tag, attrib)

>>> parser = etree.XMLPullParser(target=AttributeFilter())
>>> parser.feed('<root><child1 test="123" /><child2 evil="YES" /></root>')

>>> for action, element in parser.read_events():
...     print('%s: %s(%r)' % (action, element.tag, element.attrib))
end: child1({'test': '123'})
end: child2({})
end: root({})

>>> root = parser.close()

```
Tokens:
Raw