pyhtml2text 0.1.0__tar.gz → 0.3.0__tar.gz

pyhtml2text-0.3.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## 0.3.0 (2026-10-15)
+
+- New `html2markdown(html, *, base_url=None)`: HTML to CommonMark with
+  GitHub's tables and strikethrough. Links and images keep their URLs (made
+  absolute with `base_url`), tables become pipe tables, code blocks are
+  fenced with their language, and characters are escaped only where Markdown
+  would misread them. 3–13× faster than markdownify, html2text and
+  html-to-markdown on real pages.
+- `html2text()` output is unchanged.
+
+## 0.2.0 (2026-10-15)
+
+- 1.5–1.7× faster than 0.1.0 on real web pages, and 2× faster on short
+  snippets. Output is unchanged.
+  - Wheels for Linux x86_64/aarch64, macOS and Windows x64 are built with
+    profile-guided optimisation.
+  - Uses mimalloc as the allocator (except on glibc armv7, ppc64le and s390x).
+  - Style rules are shared rather than rebuilt and copied for every call.
+- Deeply nested HTML no longer takes quadratic time to parse: 40,000 nested
+  `<ul>` lists went from 6s to 0.14s (patched html5ever, see `vendor/`).
+- `html` can be UTF-8 `bytes` as well as `str`.
+- An internal error now raises `ValueError` rather than `PanicException`
+  (which `except Exception` doesn't catch).
+- Supports free-threaded Python without re-enabling the GIL.
+- Requires Python 3.10 or later (3.9 is end-of-life).
+
+## 0.1.0 (2026-10-15)
+
+- First release: `html2text()` with `base_url` support.

{pyhtml2text-0.1.0 → pyhtml2text-0.3.0}/Cargo.lock

@@ -14,6 +14,16 @@ version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
+[[package]]
+name = "cc"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6651c9ed80effdc7db0ff72512157f901af5e3549e341e24b1dd4887d836d838"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.5"
@@ -26,6 +36,12 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -35,7 +51,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "html2text"
 version = "0.17.1"
-source = "git+https://github.com/jaredlynskey/rust-html2text?rev=ee049006a900891e9df46299004c38ff59c41d65#ee049006a900891e9df46299004c38ff59c41d65"
+source = "git+https://github.com/jaredlynskey/rust-html2text?rev=b42930f8e6688ea121daf392e27a7d9812e6192d#b42930f8e6688ea121daf392e27a7d9812e6192d"
 dependencies = [
  "html5ever",
  "tendril",
@@ -46,8 +62,6 @@ dependencies = [
 [[package]]
 name = "html5ever"
 version = "0.39.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8"
 dependencies = [
  "log",
  "markup5ever",
@@ -68,6 +82,15 @@ version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.14"
@@ -94,6 +117,12 @@ dependencies = [
  "web_atoms",
 ]
 
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -103,6 +132,15 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "new_debug_unreachable"
 version = "1.0.6"
@@ -198,11 +236,25 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pulldown-cmark"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e"
+dependencies = [
+ "bitflags",
+ "memchr",
+ "unicase",
+]
+
 [[package]]
 name = "pyhtml2text"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "html2text",
+ "html5ever",
+ "mimalloc",
+ "pulldown-cmark",
  "pyo3",
 ]
 
@@ -326,6 +378,12 @@ dependencies = [
  "syn 3.0.9",
 ]
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "siphasher"
 version = "1.0.4"
@@ -419,6 +477,12 @@ dependencies = [
  "syn 3.0.9",
 ]
 
+[[package]]
+name = "unicase"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357cc3acc6a036009fd6c973ed009037c732d60d0b4f6c673e9041497482a28f"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.27"

pyhtml2text-0.3.0/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "pyhtml2text"
+version = "0.3.0"
+edition = "2021"
+license = "MIT"
+publish = false
+readme = "README.md"
+
+[lib]
+name = "_pyhtml2text"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.26", features = ["extension-module", "abi3-py310"] }
+# Fork of jugglerchris/rust-html2text with Config::base_url, some performance
+# changes and the DOM exports the Markdown output uses (branch pyhtml2text-perf).
+html2text = { git = "https://github.com/jaredlynskey/rust-html2text", rev = "b42930f8e6688ea121daf392e27a7d9812e6192d" }
+# The parser html2text uses; patched below. Used directly to read element attributes.
+html5ever = "0.39"
+# Reads the Markdown back to check that emphasis parses as intended.
+pulldown-cmark = { version = "0.13", default-features = false }
+
+# Much faster than the system allocators for html2text's many small allocations.
+# Not on glibc armv7/ppc64le/s390x: their manylinux2014 cross compilers are too
+# old to build it (keep in sync with the cfg in src/lib.rs).
+[target.'cfg(not(all(target_env = "gnu", any(target_arch = "arm", target_arch = "powerpc64", target_arch = "s390x"))))'.dependencies]
+mimalloc = { version = "0.1", default-features = false, features = ["local_dynamic_tls"] }
+
+[patch.crates-io]
+# Fixes quadratic parsing of deeply nested HTML, see vendor/README.md.
+html5ever = { path = "vendor/html5ever" }
+
+[profile.release]
+lto = true
+codegen-units = 1
+strip = true

pyhtml2text-0.3.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: pyhtml2text
+Version: 0.3.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup :: HTML
+License-File: LICENSE
+Summary: Fast HTML to plain text, with relative link resolution (Python bindings to rust-html2text)
+Keywords: html,text,markdown,html2text
+Author-email: Jared Lynskey <jared@lynskey.co.nz>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source, https://github.com/jaredlynskey/pyhtml2text
+Project-URL: Upstream, https://github.com/jugglerchris/rust-html2text
+
+# pyhtml2text
+
+Fast HTML to plain text and to Markdown for Python, built on
+[rust-html2text](https://github.com/jugglerchris/rust-html2text).
+
+Relative links can be resolved against the page's URL, so the output's links
+work on their own.
+
+## Markdown
+
+```python
+from pyhtml2text import html2markdown
+
+html = """<h2>Before you start</h2>
+<p>Read the <a href="setup.html">setup guide</a> and <b>back up</b> your data.</p>
+<img src="/img/diagram.png" alt="How it fits together">
+<table><tr><th>Plan</th><th>Price</th></tr><tr><td>Basic</td><td>Free</td></tr></table>"""
+
+print(html2markdown(html, base_url="https://example.com/docs/intro.html"))
+```
+
+```markdown
+## Before you start
+
+Read the [setup guide](https://example.com/docs/setup.html) and **back up** your data.
+
+![How it fits together](https://example.com/img/diagram.png)
+
+| Plan | Price |
+| --- | --- |
+| Basic | Free |
+```
+
+`html2markdown(html, *, base_url=None)` writes
+[CommonMark](https://commonmark.org/) with GitHub's tables and
+strikethrough, in the usual conventions:
+
+- `#` headings, `-` bullets, `_emphasis_` and `**strong**`, `~~strikethrough~~`.
+- Inline links and images, `[text](url)` and `![alt](src)`, made absolute when
+  `base_url` is given. A link whose only content is an icon uses its
+  `aria-label` or `title` as its text.
+- Fenced code blocks, tagged with the language when the page names one
+  (`class="language-python"`).
+- Pipe tables. Cells spanning rows or columns become empty cells, a table
+  without a header row gets an empty one, and tables used for page layout are
+  written as plain paragraphs.
+- Characters are escaped only where Markdown would otherwise read them as
+  syntax, so `snake_case`, `5 * 3` and `$5` stay as they are.
+- Lines aren't wrapped. Hidden content (`hidden`, `aria-hidden`,
+  `display: none`), scripts, styles and form controls are left out.
+
+The output is checked by rendering it back with a CommonMark parser and
+comparing every word, link and image with the original page, on real sites
+and on tens of thousands of random documents (`tests/markdown_check.py`).
+
+## Plain text
+
+```python
+from pyhtml2text import html2text
+
+html = '<p>Please <a href="/login">sign in</a> first.</p>'
+
+print(html2text(html, base_url="https://example.com/docs/page.html"))
+# Please [sign in][1] first.
+#
+# [1]: https://example.com/login
+```
+
+`html2text(html, width=80, *, ...)`
+
+| option | default | |
+|---|---|---|
+| `base_url` | `None` | resolve relative `href`s against this URL (RFC 3986). Absolute and `mailto:` etc. links are left alone |
+| `decorate` | `True` | markdown-ish `*em*`, `**strong**`, `` `code` `` |
+| `link_footnotes` | `True` | list link targets as `[1]: ...` footnotes |
+| `table_borders` | `True` | draw table borders |
+| `wrap_links` | `True` | allow long links to wrap |
+| `max_wrap_width` | `None` | wrap paragraphs narrower than `width` |
+| `raw` | `False` | flatten tables so cell text stays together |
+
+Both functions take a `str` or UTF-8 `bytes` (e.g. `response.content`).
+Requires Python 3.10 or later.
+
+## Performance
+
+Median time on an Apple Silicon Mac. To Markdown:
+
+| | Wikipedia article (1 MB) | BBC News front page (370 KB) | Python docs page (245 KB) |
+|---|---|---|---|
+| [markdownify](https://pypi.org/project/markdownify/) | 184 ms | 28 ms | 97 ms |
+| [html2text](https://pypi.org/project/html2text/) (pure Python) | 73 ms | 13 ms | 37 ms |
+| [html-to-markdown](https://pypi.org/project/html-to-markdown/) | 44 ms | 5.6 ms | 15 ms |
+| **pyhtml2text** | **14 ms** | **1.7 ms** | **4.5 ms** |
+
+To plain text:
+
+| | Wikipedia article (780 KB) | BBC News front page (370 KB) |
+|---|---|---|
+| [html2text](https://pypi.org/project/html2text/) (pure Python) | 71.5 ms | 14.9 ms |
+| [html2text-rs](https://pypi.org/project/html2text-rs/) | 15.2 ms | 2.5 ms |
+| **pyhtml2text** | **10.9 ms** | **1.6 ms** |
+
+- The GIL is released while converting, so threads scale across cores. On
+  free-threaded Python (3.14t) the module runs without re-enabling the GIL.
+- Wheels for Linux (x86_64, aarch64), macOS and Windows x64 are built with
+  profile-guided optimisation, which makes them about 25% faster. Other
+  platforms get the same code without it.
+- Deeply nested HTML is parsed in linear time, so hostile input can't stall a
+  worker: 40,000 nested lists take 0.14 s, against 6 s with stock html5ever.
+
+## Credits
+
+The plain-text rendering is done by rust-html2text by Chris Emerson (MIT).
+This package uses [a fork](https://github.com/jaredlynskey/rust-html2text/tree/pyhtml2text-perf)
+that adds `base_url` and some performance changes, and a patched copy of
+[html5ever](https://github.com/servo/html5ever) (MIT/Apache-2.0, see
+`vendor/`). Markdown output is checked with
+[pulldown-cmark](https://github.com/raphlinus/pulldown-cmark) (MIT). It
+isn't affiliated with or endorsed by any of these projects, so please report
+issues here rather than upstream.
+

pyhtml2text-0.3.0/README.md

@@ -0,0 +1,120 @@
+# pyhtml2text
+
+Fast HTML to plain text and to Markdown for Python, built on
+[rust-html2text](https://github.com/jugglerchris/rust-html2text).
+
+Relative links can be resolved against the page's URL, so the output's links
+work on their own.
+
+## Markdown
+
+```python
+from pyhtml2text import html2markdown
+
+html = """<h2>Before you start</h2>
+<p>Read the <a href="setup.html">setup guide</a> and <b>back up</b> your data.</p>
+<img src="/img/diagram.png" alt="How it fits together">
+<table><tr><th>Plan</th><th>Price</th></tr><tr><td>Basic</td><td>Free</td></tr></table>"""
+
+print(html2markdown(html, base_url="https://example.com/docs/intro.html"))
+```
+
+```markdown
+## Before you start
+
+Read the [setup guide](https://example.com/docs/setup.html) and **back up** your data.
+
+![How it fits together](https://example.com/img/diagram.png)
+
+| Plan | Price |
+| --- | --- |
+| Basic | Free |
+```
+
+`html2markdown(html, *, base_url=None)` writes
+[CommonMark](https://commonmark.org/) with GitHub's tables and
+strikethrough, in the usual conventions:
+
+- `#` headings, `-` bullets, `_emphasis_` and `**strong**`, `~~strikethrough~~`.
+- Inline links and images, `[text](url)` and `![alt](src)`, made absolute when
+  `base_url` is given. A link whose only content is an icon uses its
+  `aria-label` or `title` as its text.
+- Fenced code blocks, tagged with the language when the page names one
+  (`class="language-python"`).
+- Pipe tables. Cells spanning rows or columns become empty cells, a table
+  without a header row gets an empty one, and tables used for page layout are
+  written as plain paragraphs.
+- Characters are escaped only where Markdown would otherwise read them as
+  syntax, so `snake_case`, `5 * 3` and `$5` stay as they are.
+- Lines aren't wrapped. Hidden content (`hidden`, `aria-hidden`,
+  `display: none`), scripts, styles and form controls are left out.
+
+The output is checked by rendering it back with a CommonMark parser and
+comparing every word, link and image with the original page, on real sites
+and on tens of thousands of random documents (`tests/markdown_check.py`).
+
+## Plain text
+
+```python
+from pyhtml2text import html2text
+
+html = '<p>Please <a href="/login">sign in</a> first.</p>'
+
+print(html2text(html, base_url="https://example.com/docs/page.html"))
+# Please [sign in][1] first.
+#
+# [1]: https://example.com/login
+```
+
+`html2text(html, width=80, *, ...)`
+
+| option | default | |
+|---|---|---|
+| `base_url` | `None` | resolve relative `href`s against this URL (RFC 3986). Absolute and `mailto:` etc. links are left alone |
+| `decorate` | `True` | markdown-ish `*em*`, `**strong**`, `` `code` `` |
+| `link_footnotes` | `True` | list link targets as `[1]: ...` footnotes |
+| `table_borders` | `True` | draw table borders |
+| `wrap_links` | `True` | allow long links to wrap |
+| `max_wrap_width` | `None` | wrap paragraphs narrower than `width` |
+| `raw` | `False` | flatten tables so cell text stays together |
+
+Both functions take a `str` or UTF-8 `bytes` (e.g. `response.content`).
+Requires Python 3.10 or later.
+
+## Performance
+
+Median time on an Apple Silicon Mac. To Markdown:
+
+| | Wikipedia article (1 MB) | BBC News front page (370 KB) | Python docs page (245 KB) |
+|---|---|---|---|
+| [markdownify](https://pypi.org/project/markdownify/) | 184 ms | 28 ms | 97 ms |
+| [html2text](https://pypi.org/project/html2text/) (pure Python) | 73 ms | 13 ms | 37 ms |
+| [html-to-markdown](https://pypi.org/project/html-to-markdown/) | 44 ms | 5.6 ms | 15 ms |
+| **pyhtml2text** | **14 ms** | **1.7 ms** | **4.5 ms** |
+
+To plain text:
+
+| | Wikipedia article (780 KB) | BBC News front page (370 KB) |
+|---|---|---|
+| [html2text](https://pypi.org/project/html2text/) (pure Python) | 71.5 ms | 14.9 ms |
+| [html2text-rs](https://pypi.org/project/html2text-rs/) | 15.2 ms | 2.5 ms |
+| **pyhtml2text** | **10.9 ms** | **1.6 ms** |
+
+- The GIL is released while converting, so threads scale across cores. On
+  free-threaded Python (3.14t) the module runs without re-enabling the GIL.
+- Wheels for Linux (x86_64, aarch64), macOS and Windows x64 are built with
+  profile-guided optimisation, which makes them about 25% faster. Other
+  platforms get the same code without it.
+- Deeply nested HTML is parsed in linear time, so hostile input can't stall a
+  worker: 40,000 nested lists take 0.14 s, against 6 s with stock html5ever.
+
+## Credits
+
+The plain-text rendering is done by rust-html2text by Chris Emerson (MIT).
+This package uses [a fork](https://github.com/jaredlynskey/rust-html2text/tree/pyhtml2text-perf)
+that adds `base_url` and some performance changes, and a patched copy of
+[html5ever](https://github.com/servo/html5ever) (MIT/Apache-2.0, see
+`vendor/`). Markdown output is checked with
+[pulldown-cmark](https://github.com/raphlinus/pulldown-cmark) (MIT). It
+isn't affiliated with or endorsed by any of these projects, so please report
+issues here rather than upstream.

{pyhtml2text-0.1.0 → pyhtml2text-0.3.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "maturin"
 
 [project]
 name = "pyhtml2text"
-version = "0.1.0"
+version = "0.3.0"
 description = "Fast HTML to plain text, with relative link resolution (Python bindings to rust-html2text)"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [{ name = "Jared Lynskey", email = "jared@lynskey.co.nz" }]
 keywords = ["html", "text", "markdown", "html2text"]
 classifiers = [
@@ -25,6 +25,19 @@ Upstream = "https://github.com/jugglerchris/rust-html2text"
 [tool.maturin]
 python-source = "python"
 module-name = "pyhtml2text._pyhtml2text"
+# cargo leaves out vendor/html5ever (it has its own Cargo.toml), but the
+# [patch] in Cargo.toml needs it; the PGO data and CI files aren't needed.
+include = [
+  { path = "vendor/html5ever/Cargo.toml", format = "sdist" },
+  { path = "vendor/html5ever/LICENSE-*", format = "sdist" },
+  { path = "vendor/html5ever/README.md", format = "sdist" },
+  { path = "vendor/html5ever/src/**/*.rs", format = "sdist" },
+]
+exclude = [
+  { path = "pgo/**/*", format = "sdist" },
+  { path = "bench/**/*", format = "sdist" },
+  { path = ".github/**/*", format = "sdist" },
+]
 
 [tool.maturin.generate-ci.github]
 pytest = true

pyhtml2text-0.3.0/python/pyhtml2text/__init__.py

@@ -0,0 +1,3 @@
+from ._pyhtml2text import html2markdown, html2text
+
+__all__ = ["html2markdown", "html2text"]

{pyhtml2text-0.1.0 → pyhtml2text-0.3.0}/python/pyhtml2text/__init__.pyi

@@ -1,14 +1,13 @@
-from typing import Optional
-
 def html2text(
-    html: str,
+    html: str | bytes,
     width: int = 80,
     *,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     decorate: bool = True,
     link_footnotes: bool = True,
     table_borders: bool = True,
     wrap_links: bool = True,
-    max_wrap_width: Optional[int] = None,
+    max_wrap_width: int | None = None,
     raw: bool = False,
 ) -> str: ...
+def html2markdown(html: str | bytes, *, base_url: str | None = None) -> str: ...

pyhtml2text-0.3.0/src/lib.rs

@@ -0,0 +1,130 @@
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+use html2text::config;
+use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyString};
+
+mod markdown;
+
+#[cfg(not(all(
+    target_env = "gnu",
+    any(target_arch = "arm", target_arch = "powerpc64", target_arch = "s390x")
+)))]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+/// Borrow the input without copying it; bytes are taken to be UTF-8.
+fn input_bytes<'a>(html: &'a Bound<'_, PyAny>) -> PyResult<&'a [u8]> {
+    if let Ok(s) = html.downcast::<PyString>() {
+        Ok(s.to_str()?.as_bytes())
+    } else if let Ok(b) = html.downcast::<PyBytes>() {
+        Ok(b.as_bytes())
+    } else {
+        Err(PyTypeError::new_err(format!(
+            "html must be str or bytes, not {}",
+            html.get_type().name()?
+        )))
+    }
+}
+
+/// Run a conversion. It is pure Rust, so other Python threads run meanwhile.
+/// A panic would otherwise surface as PanicException, which `except
+/// Exception` doesn't catch, so it is reported as a ValueError instead.
+fn convert<F>(py: Python<'_>, f: F) -> PyResult<String>
+where
+    F: FnOnce() -> Result<String, html2text::Error> + Send,
+{
+    match py.detach(|| catch_unwind(AssertUnwindSafe(|| f().map_err(|e| e.to_string())))) {
+        Ok(Ok(text)) => Ok(text),
+        Ok(Err(e)) => Err(PyValueError::new_err(e)),
+        Err(panic) => {
+            let msg = panic
+                .downcast_ref::<&str>()
+                .copied()
+                .or_else(|| panic.downcast_ref::<String>().map(String::as_str))
+                .unwrap_or("unknown error");
+            Err(PyValueError::new_err(format!(
+                "html2text failed on this document: {msg}"
+            )))
+        }
+    }
+}
+
+/// Render HTML as plain text.
+#[pyfunction]
+#[pyo3(name = "html2text", signature = (
+    html,
+    width = 80,
+    *,
+    base_url = None,
+    decorate = true,
+    link_footnotes = true,
+    table_borders = true,
+    wrap_links = true,
+    max_wrap_width = None,
+    raw = false,
+))]
+#[allow(clippy::too_many_arguments)]
+fn render(
+    py: Python<'_>,
+    html: &Bound<'_, PyAny>,
+    width: usize,
+    base_url: Option<String>,
+    decorate: bool,
+    link_footnotes: bool,
+    table_borders: bool,
+    wrap_links: bool,
+    max_wrap_width: Option<usize>,
+    raw: bool,
+) -> PyResult<String> {
+    let input = input_bytes(html)?;
+
+    let mut conf = if decorate {
+        config::plain()
+    } else {
+        config::plain_no_decorate()
+    };
+    conf = conf.link_footnotes(link_footnotes).allow_width_overflow();
+    if let Some(base) = base_url {
+        conf = conf.base_url(base);
+    }
+    if !table_borders {
+        conf = conf.no_table_borders();
+    }
+    if !wrap_links {
+        conf = conf.no_link_wrapping();
+    }
+    if let Some(w) = max_wrap_width {
+        conf = conf.max_wrap_width(w);
+    }
+    if raw {
+        conf = conf.raw_mode(true);
+    }
+
+    convert(py, || conf.string_from_read(input, width))
+}
+
+/// Convert HTML to Markdown.
+///
+/// The output is CommonMark with GitHub's pipe tables and strikethrough:
+/// ATX headings, `-` bullets, fenced code blocks and inline links and images.
+/// Lines are not wrapped. Relative links and image sources are resolved
+/// against `base_url` when one is given.
+#[pyfunction]
+#[pyo3(name = "html2markdown", signature = (html, *, base_url = None))]
+fn to_markdown(
+    py: Python<'_>,
+    html: &Bound<'_, PyAny>,
+    base_url: Option<String>,
+) -> PyResult<String> {
+    let input = input_bytes(html)?;
+    convert(py, || markdown::from_read(input, base_url.as_deref()))
+}
+
+#[pymodule(gil_used = false)]
+fn _pyhtml2text(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(render, m)?)?;
+    m.add_function(wrap_pyfunction!(to_markdown, m)?)?;
+    Ok(())
+}