.*)"
+).match
+
+
+def run(command, cwd=None, pythonpath=None, c_macros=None):
+ env = None
+ if pythonpath:
+ env = os.environ.copy()
+ env['PYTHONPATH'] = pythonpath
+ if c_macros:
+ env = env or os.environ.copy()
+ env['CFLAGS'] = env.get('CFLAGS', '') + " " + ' '.join(f" -D{macro}" for macro in c_macros)
+
+ try:
+ return subprocess.run(command, cwd=cwd, check=True, capture_output=True, env=env)
+ except subprocess.CalledProcessError as exc:
+ logging.error(f"Command failed: {' '.join(map(str, command))}\nOutput:\n{exc.stderr.decode()}")
+ raise
+
+
+def copy_benchmarks(bm_dir: pathlib.Path, benchmarks=None):
+ bm_files = []
+ shutil.copy(BENCHMARKS_DIR / 'benchbase.py', bm_dir / 'benchbase.py')
+ for bm_src_file in BENCHMARK_FILES:
+ if benchmarks and bm_src_file.stem not in benchmarks:
+ continue
+ bm_file = bm_dir / bm_src_file.name
+ for benchmark_file in BENCHMARKS_DIR.glob(bm_src_file.stem + ".*"):
+ shutil.copy(benchmark_file, bm_dir / benchmark_file.name)
+ bm_files.append(bm_file)
+
+ return bm_files
+
+
+def compile_lxml(lxml_dir: pathlib.Path, c_macros=None):
+ rev_hash = get_git_rev(rev_dir=lxml_dir)
+ logging.info(f"Compiling lxml gitrev {rev_hash}")
+ run(
+ [sys.executable, "setup.py", "build_ext", "-i", "-j6"],
+ cwd=lxml_dir,
+ c_macros=c_macros,
+ )
+
+
+def get_git_rev(revision=None, rev_dir=None):
+ command = ["git", "describe", "--long"]
+ if revision:
+ command.append(revision)
+ output = run(command, cwd=rev_dir)
+ _, rev_hash = output.stdout.decode().strip().rsplit('-', 1)
+ return rev_hash[1:]
+
+
+def git_clone(rev_dir, revision):
+ rev_hash = get_git_rev(revision)
+ run(["git", "clone", "-n", "--no-single-branch", ".", str(rev_dir)])
+ run(["git", "checkout", rev_hash], cwd=rev_dir)
+
+
+def copy_profile(bm_dir, module_name, profiler):
+ timestamp = int(time.time() * 1000)
+ profile_input = bm_dir / "profile.out"
+ data_file_name = f"{profiler}_{module_name}_{timestamp:X}.data"
+
+ if profiler == 'callgrind':
+ bm_dir_str = str(bm_dir) + os.sep
+ with open(profile_input) as data_file_in:
+ with open(data_file_name, mode='w') as data_file_out:
+ for line in data_file_in:
+ if bm_dir_str in line:
+ # Remove absolute file paths to link to local file copy below.
+ line = line.replace(bm_dir_str, "")
+ data_file_out.write(line)
+ else:
+ shutil.move(profile_input, data_file_name)
+
+ for result_file_name in (f"{module_name}.c", f"{module_name}.html"):
+ result_file = bm_dir / result_file_name
+ if result_file.exists():
+ shutil.move(result_file, result_file_name)
+
+ for ext in bm_dir.glob(f"{module_name}.*so"):
+ shutil.move(str(ext), ext.name)
+
+
+def run_benchmark(bm_dir, module_name, pythonpath=None, profiler=None):
+ logging.info(f"Running benchmark '{module_name}'.")
+
+ command = []
+
+ if profiler:
+ if profiler == 'perf':
+ command = ["perf", "record", "--quiet", "-g", "--output=profile.out"]
+ elif profiler == 'callgrind':
+ command = [
+ "valgrind", "--tool=callgrind",
+ "--dump-instr=yes", "--collect-jumps=yes",
+ "--callgrind-out-file=profile.out",
+ ]
+
+ command += [sys.executable, f"{module_name}.py"]
+
+ output = run(command, cwd=bm_dir, pythonpath=pythonpath)
+
+ if profiler:
+ copy_profile(bm_dir, module_name, profiler)
+
+ lines = filter(None, output.stdout.decode().splitlines())
+ for line in lines:
+ if line == "Setup times for trees in seconds:":
+ break
+
+ other_lines = []
+ timings = []
+ for line in lines:
+ match = parse_timings(line)
+ if match:
+ timings.append((match['benchmark'], match['params'].strip(), match['lib'], float(match['besttime']), match['timings']))
+ else:
+ other_lines.append(line)
+
+ return other_lines, timings
+
+
+def run_benchmarks(bm_dir, benchmarks, pythonpath=None, profiler=None):
+ timings = {}
+ for benchmark in benchmarks:
+ timings[benchmark] = run_benchmark(bm_dir, benchmark, pythonpath=pythonpath, profiler=profiler)
+ return timings
+
+
+def benchmark_revisions(benchmarks, revisions, profiler=None, limited_revisions=(), deps_zipfile=None):
+ python_version = "Python %d.%d.%d" % sys.version_info[:3]
+ logging.info(f"### Comparing revisions in {python_version}: {' '.join(revisions)}.")
+ logging.info(f"CFLAGS={os.environ.get('CFLAGS', DISTUTILS_CFLAGS)}")
+
+ hashes = {}
+ timings = {}
+ for revision in revisions:
+ rev_hash = get_git_rev(revision)
+ if rev_hash in hashes:
+ logging.info(f"### Ignoring revision '{revision}': same as '{hashes[rev_hash]}'")
+ continue
+ hashes[rev_hash] = revision
+
+ logging.info(f"### Preparing benchmark run for lxml '{revision}'.")
+ timings[revision] = benchmark_revision(
+ revision, benchmarks, profiler, deps_zipfile=deps_zipfile)
+
+ if revision in limited_revisions:
+ logging.info(
+ f"### Preparing benchmark run for lxml '{revision}' (Limited API {LIMITED_API_VERSION[0]}.{LIMITED_API_VERSION[1]}).")
+ timings['L-' + revision] = benchmark_revision(
+ revision, benchmarks, profiler,
+ c_macros=["Py_LIMITED_API=0x%02x%02x0000" % LIMITED_API_VERSION],
+ deps_zipfile=deps_zipfile,
+ )
+
+ return timings
+
+
+def cache_libs(lxml_dir, deps_zipfile):
+ for dir_path, _, filenames in (lxml_dir / "build" / "tmp").walk():
+ for filename in filenames:
+ path = dir_path / filename
+ deps_zipfile.write(path, path.relative_to(lxml_dir))
+
+
+def benchmark_revision(revision, benchmarks, profiler=None, c_macros=None, deps_zipfile=None):
+ with tempfile.TemporaryDirectory() as base_dir_str:
+ base_dir = pathlib.Path(base_dir_str)
+ lxml_dir = base_dir / "lxml" / revision
+ bm_dir = base_dir / "benchmarks" / revision
+
+ git_clone(lxml_dir, revision=revision)
+
+ bm_dir.mkdir(parents=True)
+ bm_files = copy_benchmarks(bm_dir, benchmarks)
+
+ deps_zip_is_empty = deps_zipfile and not deps_zipfile.namelist()
+ if deps_zipfile and not deps_zip_is_empty:
+ deps_zipfile.extractall(lxml_dir)
+
+ compile_lxml(lxml_dir, c_macros=c_macros)
+
+ if deps_zipfile and deps_zip_is_empty:
+ cache_libs(lxml_dir, deps_zipfile)
+
+ logging.info(f"### Running benchmarks for {revision}: {' '.join(bm.stem for bm in bm_files)}")
+ return run_benchmarks(bm_dir, benchmarks, pythonpath=f"{bm_dir}:{lxml_dir / 'src'}", profiler=profiler)
+
+
+def report_revision_timings(rev_timings):
+ units = {"nsec": 1e-9, "usec": 1e-6, "msec": 1e-3, "sec": 1.0}
+ scales = [(scale, unit) for unit, scale in reversed(units.items())] # biggest first
+
+ def format_time(t):
+ pos_t = abs(t)
+ for scale, unit in scales:
+ if pos_t >= scale:
+ break
+ else:
+ raise RuntimeError(f"Timing is below nanoseconds: {t:f}")
+ return f"{t / scale :+.3f} {unit}"
+
+ timings_by_benchmark = collections.defaultdict(list)
+ setup_times = []
+ for revision_name, bm_timings in rev_timings.items():
+ for benchmark_module, (output, timings) in bm_timings.items():
+ setup_times.append((benchmark_module, revision_name, output))
+ for benchmark_name, params, lib, best_time, result_text in timings:
+ timings_by_benchmark[(benchmark_module, benchmark_name, params)].append((lib, revision_name, best_time, result_text))
+
+ setup_times.sort()
+ for timings in timings_by_benchmark.values():
+ timings.sort()
+
+ for benchmark_module, revision_name, output in setup_times:
+ result = '\n'.join(output)
+ logging.info(f"Setup times for trees in seconds - {benchmark_module} / {revision_name}:\n{result}")
+
+ differences = collections.defaultdict(list)
+ for (benchmark_module, benchmark_name, params), timings in timings_by_benchmark.items():
+ logging.info(f"### Benchmark {benchmark_module} / {benchmark_name} ({params}):")
+ base_line = timings[0][2]
+ for lib, revision_name, bm_time, result_text in timings:
+ diff_str = ""
+ if base_line != bm_time:
+ pdiff = bm_time * 100 / base_line - 100
+ differences[(lib, revision_name)].append((abs(pdiff), pdiff, bm_time - base_line, benchmark_module, benchmark_name, params))
+ diff_str = f" {pdiff:+8.2f} %"
+ logging.info(
+ f" {lib:3} / {revision_name[:25]:25} = {bm_time:8.4f} {result_text}{diff_str}"
+ )
+
+ for (lib, revision_name), diffs in differences.items():
+ diffs.sort(reverse=True)
+ diffs_by_sign = {True: [], False: []}
+ for diff in diffs:
+ diffs_by_sign[diff[1] < 0].append(diff)
+
+ for is_win, diffs in diffs_by_sign.items():
+ if not diffs or diffs[0][0] < 1.0:
+ continue
+
+ logging.info(f"Largest {'gains' if is_win else 'losses'} for {revision_name}:")
+ cutoff = max(1.0, diffs[0][0] // 4)
+ for absdiff, pdiff, tdiff, benchmark_module, benchmark_name, params in diffs:
+ if absdiff < cutoff:
+ break
+ logging.info(f" {benchmark_module} / {benchmark_name:<25} ({params:>10}) {pdiff:+8.2f} % / {format_time(tdiff / 1000.0):>8}")
+
+
+def parse_args(args):
+ from argparse import ArgumentParser, RawDescriptionHelpFormatter
+ parser = ArgumentParser(
+ description="Run benchmarks against different lxml tags/revisions.",
+ formatter_class=RawDescriptionHelpFormatter,
+ )
+ parser.add_argument(
+ "-b", "--benchmarks",
+ dest="benchmarks", default=','.join(ALL_BENCHMARKS),
+ help="The list of benchmark selectors to run, simple substrings, separated by comma.",
+ )
+ parser.add_argument(
+ "--with-limited",
+ dest="with_limited_api", action="append", default=[],
+ help="Also run the benchmarks for REVISION against the Limited C-API.",
+ )
+ #parser.add_argument(
+ # "--with-elementtree",
+ # dest="with_elementtree",
+ # help="Include results for Python's xml.etree.ElementTree.",
+ #)
+ parser.add_argument(
+ "--perf",
+ dest="profiler", action="store_const", const="perf", default=None,
+ help="Run Linux 'perf record' on the benchmark process.",
+ )
+ parser.add_argument(
+ "--callgrind",
+ dest="profiler", action="store_const", const="callgrind", default=None,
+ help="Run Valgrind's callgrind profiler on the benchmark process.",
+ )
+ parser.add_argument(
+ "revisions",
+ nargs="*", default=[],
+ help="The git revisions to check out and benchmark.",
+ )
+
+ return parser.parse_known_args(args)
+
+
+if __name__ == '__main__':
+ options, cythonize_args = parse_args(sys.argv[1:])
+
+ logging.basicConfig(
+ stream=sys.stdout,
+ level=logging.INFO,
+ format="%(asctime)s %(message)s",
+ datefmt="%Y-%m-%d %H:%M:%S",
+ )
+
+ benchmark_selectors = set(bm.strip() for bm in options.benchmarks.split(","))
+ benchmarks = [bm for bm in ALL_BENCHMARKS if any(selector in bm for selector in benchmark_selectors)]
+ if benchmark_selectors and not benchmarks:
+ logging.error("No benchmarks selected!")
+ sys.exit(1)
+
+ deps_zipfile = zipfile.ZipFile(io.BytesIO(), mode='w')
+
+ revisions = list({rev: rev for rev in (options.revisions + options.with_limited_api)}) # deduplicate in order
+ timings = benchmark_revisions(
+ benchmarks, revisions,
+ profiler=options.profiler,
+ limited_revisions=options.with_limited_api,
+ deps_zipfile=deps_zipfile,
+ )
+ report_revision_timings(timings)
diff --git a/buildlibxml.py b/buildlibxml.py
index ab2efaddf..cc61d65b2 100644
--- a/buildlibxml.py
+++ b/buildlibxml.py
@@ -1,17 +1,14 @@
import json
import os, re, sys, subprocess, platform
import tarfile
+import time
from distutils import log
from contextlib import closing, contextmanager
from ftplib import FTP
-try:
- from urllib.parse import urljoin, unquote, urlparse
- from urllib.request import urlretrieve, urlopen, urlcleanup, Request
-except ImportError: # Py2
- from urlparse import urljoin, unquote, urlparse
- from urllib import urlretrieve, urlcleanup
- from urllib2 import urlopen, Request
+import urllib.error
+from urllib.parse import urljoin, unquote, urlparse
+from urllib.request import urlretrieve, urlopen, Request
multi_make_options = []
try:
@@ -57,9 +54,6 @@ def download_and_extract_windows_binaries(destdir):
else:
arch = "win32"
- if sys.version_info < (3, 5):
- arch = 'vs2008.' + arch
-
arch_part = '.' + arch + '.'
filenames = [filename for filename in filenames if arch_part in filename]
@@ -81,7 +75,6 @@ def download_and_extract_windows_binaries(destdir):
print('Using local copy of "{}"'.format(srcfile))
else:
print('Retrieving "%s" to "%s"' % (srcfile, destfile))
- urlcleanup() # work around FTP bug 27973 in Py2.7.12+
urlretrieve(srcfile, destfile)
d = unpack_zipfile(destfile, destdir)
libs[libname] = d
@@ -270,7 +263,7 @@ def py2_tarxz(filename):
def download_libxml2(dest_dir, version=None):
"""Downloads libxml2, returning the filename where the library was downloaded"""
#version_re = re.compile(r'LATEST_LIBXML2_IS_([0-9.]+[0-9](?:-[abrc0-9]+)?)')
- version_re = re.compile(r'libxml2-([0-9.]+[0-9]).tar.xz')
+ version_re = re.compile(r'libxml2-([0-9.]+[0-9])[.]tar[.]xz')
filename = 'libxml2-%s.tar.xz'
if version == "2.9.12":
@@ -287,7 +280,7 @@ def download_libxml2(dest_dir, version=None):
def download_libxslt(dest_dir, version=None):
"""Downloads libxslt, returning the filename where the library was downloaded"""
#version_re = re.compile(r'LATEST_LIBXSLT_IS_([0-9.]+[0-9](?:-[abrc0-9]+)?)')
- version_re = re.compile(r'libxslt-([0-9.]+[0-9]).tar.xz')
+ version_re = re.compile(r'libxslt-([0-9.]+[0-9])[.]tar[.]xz')
filename = 'libxslt-%s.tar.xz'
from_location = http_find_latest_version_directory(LIBXSLT_LOCATION, version=version)
return download_library(dest_dir, from_location, 'libxslt',
@@ -296,7 +289,7 @@ def download_libxslt(dest_dir, version=None):
def download_libiconv(dest_dir, version=None):
"""Downloads libiconv, returning the filename where the library was downloaded"""
- version_re = re.compile(r'libiconv-([0-9.]+[0-9]).tar.gz')
+ version_re = re.compile(r'libiconv-([0-9.]+[0-9])[.]tar[.]gz')
filename = 'libiconv-%s.tar.gz'
return download_library(dest_dir, LIBICONV_LOCATION, 'libiconv',
version_re, filename, version=version)
@@ -304,7 +297,7 @@ def download_libiconv(dest_dir, version=None):
def download_zlib(dest_dir, version):
"""Downloads zlib, returning the filename where the library was downloaded"""
- version_re = re.compile(r'zlib-([0-9.]+[0-9]).tar.gz')
+ version_re = re.compile(r'zlib-([0-9.]+[0-9])[.]tar[.]gz')
filename = 'zlib-%s.tar.gz'
return download_library(dest_dir, ZLIB_LOCATION, 'zlib',
version_re, filename, version=version)
@@ -334,10 +327,10 @@ def download_library(dest_dir, location, name, version_re, filename, version=Non
if version is None:
try:
if location.startswith('ftp://'):
- fns = remote_listdir(location)
+ fns = list(remote_listdir(location))
else:
- print(location)
fns = http_listfiles(location, '(%s)' % filename.replace('%s', '(?:[0-9.]+[0-9])'))
+ print(f"Found {len(fns)} links at {location}")
version = find_max_version(name, fns, version_re)
except IOError:
# network failure - maybe we have the files already?
@@ -356,16 +349,25 @@ def download_library(dest_dir, location, name, version_re, filename, version=Non
raise
if version:
filename = filename % version
+
full_url = urljoin(location, filename)
dest_filename = os.path.join(dest_dir, filename)
if os.path.exists(dest_filename):
print(('Using existing %s downloaded into %s '
'(delete this file if you want to re-download the package)') % (
name, dest_filename))
- else:
- print('Downloading %s into %s from %s' % (name, dest_filename, full_url))
- urlcleanup() # work around FTP bug 27973 in Py2.7.12
+ return dest_filename
+
+ print('Downloading %s into %s from %s' % (name, dest_filename, full_url))
+ try:
urlretrieve(full_url, dest_filename)
+ except urllib.error.URLError as exc:
+ # retry once
+ retry_after_seconds = 2
+ print(f"Download failed: {exc}, retrying in {int(retry_after_seconds)} seconds…")
+ time.sleep(retry_after_seconds)
+ urlretrieve(full_url, dest_filename)
+
return dest_filename
@@ -442,18 +444,24 @@ def build_libxml2xslt(download_dir, build_dir,
libxslt_version=None,
libiconv_version=None,
zlib_version=None,
- multicore=None):
+ multicore=None,
+ with_zlib=True):
safe_mkdir(download_dir)
safe_mkdir(build_dir)
- zlib_dir = unpack_tarball(download_zlib(download_dir, zlib_version), build_dir)
+
+ zlib_dir = None
+ if with_zlib:
+ zlib_dir = unpack_tarball(download_zlib(download_dir, zlib_version), build_dir)
+
libiconv_dir = unpack_tarball(download_libiconv(download_dir, libiconv_version), build_dir)
libxml2_dir = unpack_tarball(download_libxml2(download_dir, libxml2_version), build_dir)
libxslt_dir = unpack_tarball(download_libxslt(download_dir, libxslt_version), build_dir)
+
prefix = os.path.join(os.path.abspath(build_dir), 'libxml2')
lib_dir = os.path.join(prefix, 'lib')
safe_mkdir(prefix)
- lib_names = ['libxml2', 'libexslt', 'libxslt', 'iconv', 'libz']
+ lib_names = ['libxml2', 'libexslt', 'libxslt', 'iconv'] + (['libz'] if with_zlib else [])
existing_libs = {
lib: os.path.join(lib_dir, filename)
for lib in lib_names
@@ -484,12 +492,13 @@ def has_current_lib(name, build_dir, _build_all_following=[False]):
]
# build zlib
- zlib_configure_cmd = [
- './configure',
- '--prefix=%s' % prefix,
- ]
- if not has_current_lib("libz", zlib_dir):
- cmmi(zlib_configure_cmd, zlib_dir, multicore, **call_setup)
+ if with_zlib:
+ zlib_configure_cmd = [
+ './configure',
+ '--prefix=%s' % prefix,
+ ]
+ if not has_current_lib("libz", zlib_dir):
+ cmmi(zlib_configure_cmd, zlib_dir, multicore, **call_setup)
# build libiconv
if not has_current_lib("iconv", libiconv_dir):
@@ -499,7 +508,7 @@ def has_current_lib(name, build_dir, _build_all_following=[False]):
libxml2_configure_cmd = configure_cmd + [
'--without-python',
'--with-iconv=%s' % prefix,
- '--with-zlib=%s' % prefix,
+ ('--with-zlib=%s' % prefix) if with_zlib else '--without-zlib',
]
if not libxml2_version:
diff --git a/doc/FAQ.txt b/doc/FAQ.txt
index fb248ca92..9236a6b93 100644
--- a/doc/FAQ.txt
+++ b/doc/FAQ.txt
@@ -42,6 +42,7 @@ ElementTree_.
4.2 My application crashes on MacOS-X!
4.3 I think I have found a bug in lxml. What should I do?
4.4 How do I know a bug is really in lxml and not in libxml2?
+ 4.5 My application crashes with xmlsec!
5 Threading
5.1 Can I use threads to concurrently access the lxml API?
5.2 Does my program run faster if I use threads?
@@ -619,6 +620,18 @@ your problem.
Remember: even if you see lxml appear in a crash stack trace, it is
not necessarily lxml that *caused* the crash.
+If you are using the *``xmlsec``* library together with lxml, you have to
+make sure that both use the same version of libxml2. The binary wheels of
+lxml statically include a (usually recent) version of libxml2, whereas
+xmlsec often depends on the systemwide installed libraries. If you get
+crashes or unexpected behaviour when using both, please make sure that both
+get to use the same libxml2 version. Anaconda/condaforge/etc. based installations
+will usually come with matching C libraries. If you use xmlsec with the system
+libraries, please build lxml from sources against those as well, e.g. by installing
+the development packages of libxml2 and libxslt and then installing lxml with
+
+``python -m pip install --no-binary lxml lxml``
+
My application crashes on MacOS-X!
----------------------------------
@@ -1149,7 +1162,7 @@ safely expose their values to the evaluation engine.
The defusedxml_ package comes with an example setup and a wrapper
API for lxml that applies certain counter measures internally.
-.. _defusedxml: https://bitbucket.org/tiran/defusedxml
+.. _defusedxml: https://github.com/tiran/defusedxml
How can I sort the attributes?
diff --git a/doc/api.txt b/doc/api.txt
index 2a085d2f3..bd6867c4f 100644
--- a/doc/api.txt
+++ b/doc/api.txt
@@ -302,7 +302,7 @@ copy attached to the exception:
... '''
>>> try:
... etree.parse(StringIO(broken_xml))
- ... except etree.XMLSyntaxError, e:
+ ... except etree.XMLSyntaxError as e:
... pass # just put the exception into e
..
@@ -407,8 +407,8 @@ is required by the standard:
.. sourcecode:: pycon
- >>> unicode_root = etree.Element( u"t\u3120st" )
- >>> unicode_root.text = u"t\u0A0Ast"
+ >>> unicode_root = etree.Element( "t\u3120st" )
+ >>> unicode_root.text = "t\u0A0Ast"
>>> etree.tostring(unicode_root, encoding="utf-8")
b't\xe0\xa8\x8ast '
diff --git a/doc/build.txt b/doc/build.txt
index 58d53f16c..7a2630ceb 100644
--- a/doc/build.txt
+++ b/doc/build.txt
@@ -135,17 +135,29 @@ files to the include path like::
where the file is in ``/usr/include/libxml2/libxml/xmlversion.h``
+For static builds, if you get an error saying "recompile with -fPIC",
+do so by adding it to your `CFLAGS` environment variable:
+``env CFLAGS="$CFLAGS -fPIC"``, such as::
+
+ env CFLAGS="$CFLAGS -fPIC" python3 setup.py build_ext -i --with-cython --static-deps
+
To use lxml.etree in-place, you can place lxml's ``src`` directory
on your Python module search path (PYTHONPATH) and then import
``lxml.etree`` to play with it::
# cd lxml
- # PYTHONPATH=src python
- Python 2.7.2
+ # PYTHONPATH=src python3
+ Python 3.10.2
Type "help", "copyright", "credits" or "license" for more information.
>>> from lxml import etree
>>>
+For non-static builds, you may have to set ``LD_LIBRARY_PATH`` to where the
+shared object files for libxml2 and libxslt are, such as ``/usr/local/lib``. For
+example::
+
+ PYTHONPATH=src LD_LIBRARY_PATH=/usr/local/lib python3
+
To make sure everything gets recompiled cleanly after changes, you can
run ``make clean`` or delete the file ``src/lxml/etree.c``.
diff --git a/doc/elementsoup.txt b/doc/elementsoup.txt
index 9317f6545..a65ab94b2 100644
--- a/doc/elementsoup.txt
+++ b/doc/elementsoup.txt
@@ -115,7 +115,7 @@ finds by their character equivalent.
>>> tag_soup = '©€-õƽ'
>>> body = fromstring(tag_soup).find('.//body')
>>> body.text
- u'\xa9\u20ac-\xf5\u01bd'
+ '\xa9\u20ac-\xf5\u01bd'
If you want them back on the way out, you can just serialise with the
default encoding, which is 'US-ASCII'.
@@ -139,10 +139,10 @@ Any other encoding will output the respective byte sequences.
'
\xc2\xa9\xe2\x82\xac-\xc3\xb5\xc6\xbd
'
>>> tostring(body, encoding='unicode')
- u'\xa9\u20ac-\xf5\u01bd
'
+ '\xa9\u20ac-\xf5\u01bd
'
>>> tostring(body, method="html", encoding='unicode')
- u'\xa9\u20ac-\xf5\u01bd
'
+ '\xa9\u20ac-\xf5\u01bd
'
Using soupparser as a fallback
diff --git a/doc/lxmlhtml.txt b/doc/lxmlhtml.txt
index fa9bf1bc7..d07eacb7e 100644
--- a/doc/lxmlhtml.txt
+++ b/doc/lxmlhtml.txt
@@ -433,7 +433,7 @@ You can, for instance, do:
... name='John Smith',
... phone='555-555-3949',
... interest=set(['cats', 'llamas']))
- >>> print tostring(form)
+ >>> print(tostring(form))
- ... annoying EVIL!
- ... spam spam SPAM!
- ...
- ...
- ... '''
-
-To remove the all superfluous content from this unparsed document, use the
-``clean_html`` function:
-
-.. sourcecode:: pycon
-
- >>> from lxml.html.clean import clean_html
- >>> print clean_html(html)
-
-
-The ``Cleaner`` class supports several keyword arguments to control exactly
-which content is removed:
-
-.. sourcecode:: pycon
-
- >>> from lxml.html.clean import Cleaner
-
- >>> cleaner = Cleaner(page_structure=False, links=False)
- >>> print cleaner.clean_html(html)
-
-
- a link
- another link
- a paragraph
- secret EVIL!
- of EVIL!
- Password:
- annoying EVIL!
- spam spam SPAM!
- a link
- another link
- a paragraph
- secret EVIL!
- of EVIL!
- Password:
- annoying EVIL!
- spam spam SPAM!
- 