html-to-markdown 2.0.1__cp310-abi3-win_amd64.whl → 2.1.2__cp310-abi3-win_amd64.whl

html_to_markdown/__init__.py

@@ -23,12 +23,8 @@ from html_to_markdown.exceptions import (
     InvalidParserError,
     MissingDependencyError,
 )
-from html_to_markdown.options import (
-    ConversionOptions,
-    ParsingOptions,
-    PreprocessingOptions,
-)
-from html_to_markdown.v1_compat import convert_to_markdown, convert_to_markdown_stream, markdownify
+from html_to_markdown.options import ConversionOptions, PreprocessingOptions
+from html_to_markdown.v1_compat import convert_to_markdown, markdownify
 
 __all__ = [
     "ConflictingOptionsError",
@@ -37,12 +33,10 @@ __all__ = [
     "HtmlToMarkdownError",
     "InvalidParserError",
     "MissingDependencyError",
-    "ParsingOptions",
     "PreprocessingOptions",
     "convert",
     "convert_to_markdown",
-    "convert_to_markdown_stream",
     "markdownify",
 ]
 
-__version__ = "2.0.0"
+__version__ = "2.1.1"

html_to_markdown/_rust.pyi

@@ -21,8 +21,9 @@ class ConversionOptions:
     sub_symbol: str
     sup_symbol: str
     newline_style: str
+    keep_inline_images_in: list[str]
     preprocessing: PreprocessingOptions
-    parsing: ParsingOptions
+    encoding: str
 
     def __init__(
         self,
@@ -48,8 +49,9 @@ class ConversionOptions:
         sub_symbol: str = "",
         sup_symbol: str = "",
         newline_style: str = "spaces",
+        keep_inline_images_in: list[str] | None = None,
         preprocessing: PreprocessingOptions | None = None,
-        parsing: ParsingOptions | None = None,
+        encoding: str = "utf-8",
     ) -> None: ...
 
 class PreprocessingOptions:
@@ -66,14 +68,4 @@ class PreprocessingOptions:
         remove_forms: bool = True,
     ) -> None: ...
 
-class ParsingOptions:
-    encoding: str
-    parser: str | None
-
-    def __init__(
-        self,
-        encoding: str = "utf-8",
-        parser: str | None = None,
-    ) -> None: ...
-
 def convert(html: str, options: ConversionOptions | None = None) -> str: ...

html_to_markdown/api.py

@@ -7,47 +7,28 @@ using the Rust backend for conversion.
 from __future__ import annotations
 
 import html_to_markdown._html_to_markdown as _rust  # type: ignore[import-not-found]
-from html_to_markdown.options import (
-    ConversionOptions,
-    ParsingOptions,
-    PreprocessingOptions,
-)
+from html_to_markdown.options import ConversionOptions, PreprocessingOptions
 
 
 def convert(
     html: str,
     options: ConversionOptions | None = None,
     preprocessing: PreprocessingOptions | None = None,
-    parsing: ParsingOptions | None = None,
 ) -> str:
-    """Convert HTML to Markdown using Rust backend.
-
-    This is the main entry point for the v2 API, using dataclass-based configuration
-    and Rust implementation for high-performance conversion.
+    """Convert HTML to Markdown using the Rust backend.
 
     Args:
-        html: HTML string to convert
-        options: Conversion options (uses defaults if None)
-        preprocessing: HTML preprocessing options (uses defaults if None)
-        parsing: HTML parsing options (uses defaults if None)
+        html: HTML string to convert.
+        options: Conversion configuration options (defaults to ConversionOptions()).
+        preprocessing: HTML preprocessing options (defaults to PreprocessingOptions()).
 
     Returns:
-        Markdown string
-
-    Example:
-        >>> from html_to_markdown import convert, ConversionOptions
-        >>> options = ConversionOptions(heading_style="atx", list_indent_width=2)
-        >>> markdown = convert("<h1>Title</h1>", options)
-        >>> print(markdown)
-        # Title
-        <BLANKLINE>
+        Converted Markdown string.
     """
     if options is None:
         options = ConversionOptions()
     if preprocessing is None:
         preprocessing = PreprocessingOptions()
-    if parsing is None:
-        parsing = ParsingOptions()
 
     rust_preprocessing = _rust.PreprocessingOptions(
         enabled=preprocessing.enabled,
@@ -56,11 +37,6 @@ def convert(
         remove_forms=preprocessing.remove_forms,
     )
 
-    rust_parsing = _rust.ParsingOptions(
-        encoding=parsing.encoding,
-        parser=parsing.parser,
-    )
-
     rust_options = _rust.ConversionOptions(
         heading_style=options.heading_style,
         list_indent_type=options.list_indent_type,
@@ -75,9 +51,6 @@ def convert(
         autolinks=options.autolinks,
         default_title=options.default_title,
         br_in_tables=options.br_in_tables,
-        hocr_extract_tables=options.hocr_extract_tables,
-        hocr_table_column_threshold=options.hocr_table_column_threshold,
-        hocr_table_row_threshold_ratio=options.hocr_table_row_threshold_ratio,
         highlight_style=options.highlight_style,
         extract_metadata=options.extract_metadata,
         whitespace_mode=options.whitespace_mode,
@@ -91,7 +64,7 @@ def convert(
         code_block_style=options.code_block_style,
         keep_inline_images_in=list(options.keep_inline_images_in) if options.keep_inline_images_in else [],
         preprocessing=rust_preprocessing,
-        parsing=rust_parsing,
+        encoding=options.encoding,
         debug=options.debug,
         strip_tags=list(options.strip_tags) if options.strip_tags else [],
     )

html_to_markdown/cli.py

@@ -1,9 +1,3 @@
-"""CLI wrapper that proxies to Rust CLI binary.
-
-This module provides backwards compatibility for code that imports
-from html_to_markdown.cli. The actual CLI implementation is in Rust.
-"""
-
 from html_to_markdown.cli_proxy import main
 
 __all__ = ["main"]

html_to_markdown/cli_proxy.py

@@ -1,25 +1,19 @@
-"""CLI proxy that calls the Rust CLI binary.
-
-This module provides a Python wrapper around the Rust CLI binary,
-allowing the Python package to use the high-performance Rust implementation
-for command-line operations. It also provides v1 -> v2 CLI argument translation.
-"""
-
 import subprocess
 import sys
+import warnings
 from pathlib import Path
 
 from html_to_markdown.exceptions import RedundantV1FlagError, RemovedV1FlagError
 
 
 def find_cli_binary() -> Path:
-    """Find the html-to-markdown CLI binary.
+    """Find the html-to-markdown CLI binary in expected locations.
 
     Returns:
-        Path to the CLI binary
+        Path to the CLI binary.
 
     Raises:
-        FileNotFoundError: If the binary cannot be found
+        FileNotFoundError: If the binary cannot be found.
     """
     binary_name = "html-to-markdown.exe" if sys.platform == "win32" else "html-to-markdown"
 
@@ -38,28 +32,22 @@ def find_cli_binary() -> Path:
 
 
 def translate_v1_args_to_v2(argv: list[str]) -> list[str]:
-    """Translate v1 CLI arguments to v2 Rust CLI arguments.
-
-    This handles differences between the v1 Python CLI and v2 Rust CLI:
-    - Boolean flags: v1 used --flag/--no-flag, v2 uses presence/absence
-    - Flag name changes: --preprocess-html -> --preprocess
-    - Unsupported flags: --strip, --convert (raise errors)
+    """Translate v1 CLI arguments to v2 format.
 
     Args:
-        argv: v1 CLI arguments
+        argv: List of command-line arguments.
 
     Returns:
-        Translated v2 CLI arguments
+        Translated list of arguments compatible with v2.
 
     Raises:
-        RemovedV1FlagError: If a v1 flag has been removed in v2
+        RemovedV1FlagError: If a v1 flag has been removed in v2.
     """
     translated = []
     i = 0
     while i < len(argv):
         arg = argv[i]
 
-        # Error on removed/unsupported v1 features
         if arg in ("--strip", "--convert"):
             raise RemovedV1FlagError(
                 flag=arg,
@@ -67,8 +55,6 @@ def translate_v1_args_to_v2(argv: list[str]) -> list[str]:
                 migration="Remove this flag from your command. The feature is no longer available.",
             )
 
-        # These flags are redundant (match v2 defaults) but we accept them for v1 compatibility
-        # Silently skip - Rust CLI defaults match these flags
         if arg in (
             "--no-escape-asterisks",
             "--no-escape-underscores",
@@ -77,14 +63,21 @@ def translate_v1_args_to_v2(argv: list[str]) -> list[str]:
             "--no-autolinks",
             "--no-extract-metadata",
         ):
-            # Skip this flag - matches Rust CLI defaults
-            pass
+            warnings.warn(
+                f"'{arg}' is deprecated and redundant in v2. "
+                f"These options are now disabled by default. Remove this flag.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
 
-        # Flag name translations
         elif arg == "--preprocess-html":
+            warnings.warn(
+                "'--preprocess-html' is deprecated. Use '--preprocess' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
             translated.append("--preprocess")
 
-        # Positive flags that should be passed through
         elif arg in (
             "--escape-asterisks",
             "--escape-underscores",
@@ -95,7 +88,6 @@ def translate_v1_args_to_v2(argv: list[str]) -> list[str]:
         ):
             translated.append(arg)
 
-        # All other args pass through unchanged
         else:
             translated.append(arg)
 
@@ -105,23 +97,21 @@ def translate_v1_args_to_v2(argv: list[str]) -> list[str]:
 
 
 def main(argv: list[str]) -> str:
-    """Run the Rust CLI with the given arguments.
+    """Main entry point for the CLI proxy.
 
-    Translates v1 CLI arguments to v2 format if needed.
-    Exits with non-zero status on errors (FileNotFoundError, UnsupportedV1FeatureError, CLI errors).
+    Translates v1 arguments to v2 and invokes the native Rust CLI binary.
 
     Args:
-        argv: Command line arguments (without program name)
+        argv: Command-line arguments.
 
     Returns:
-        Output from the CLI
+        Stdout from the CLI binary.
     """
     cli_binary = find_cli_binary()
 
     try:
         translated_args = translate_v1_args_to_v2(argv)
     except (RemovedV1FlagError, RedundantV1FlagError) as e:
-        # Format the error nicely for CLI users
         sys.stderr.write(f"\n❌ Error: {e.flag}\n\n")
         sys.stderr.write(f"   {e.reason}\n\n")
         sys.stderr.write(f"   💡 {e.migration}\n\n")

html_to_markdown/exceptions.py

@@ -1,10 +1,8 @@
-"""Exception classes for html-to-markdown."""
-
 from __future__ import annotations
 
 
 class HtmlToMarkdownError(Exception):
-    """Base exception for html-to-markdown errors."""
+    """Base exception for all html-to-markdown errors."""
 
 
 class MissingDependencyError(HtmlToMarkdownError):
@@ -22,7 +20,7 @@ class MissingDependencyError(HtmlToMarkdownError):
 
 
 class InvalidParserError(HtmlToMarkdownError):
-    """Raised when an invalid HTML parser is specified."""
+    """Raised when an invalid parser is specified."""
 
     def __init__(self, parser: str, available_parsers: list[str]) -> None:
         self.parser = parser
@@ -33,14 +31,14 @@ class InvalidParserError(HtmlToMarkdownError):
 
 
 class EmptyHtmlError(HtmlToMarkdownError):
-    """Raised when the input HTML is empty."""
+    """Raised when input HTML is empty."""
 
     def __init__(self) -> None:
         super().__init__("The input HTML is empty.")
 
 
 class ConflictingOptionsError(HtmlToMarkdownError):
-    """Raised when conflicting options are specified."""
+    """Raised when conflicting configuration options are specified."""
 
     def __init__(self, option1: str, option2: str) -> None:
         self.option1 = option1
@@ -50,20 +48,14 @@ class ConflictingOptionsError(HtmlToMarkdownError):
 
 
 class InvalidEncodingError(HtmlToMarkdownError):
-    """Raised when an invalid encoding is specified."""
+    """Raised when an invalid character encoding is specified."""
 
     def __init__(self, encoding: str) -> None:
         super().__init__(f"The specified encoding ({encoding}) is not valid.")
 
 
 class UnsupportedV1FeatureError(HtmlToMarkdownError):
-    """Raised when a v1 feature is not supported in v2.
-
-    Args:
-        flag: The CLI flag or feature that is not supported
-        reason: Why the feature is not supported
-        migration: How to migrate away from this feature
-    """
+    """Raised when a v1 feature is not supported in v2."""
 
     def __init__(self, flag: str, reason: str, migration: str) -> None:
         self.flag = flag
@@ -74,8 +66,8 @@ class UnsupportedV1FeatureError(HtmlToMarkdownError):
 
 
 class RemovedV1FlagError(UnsupportedV1FeatureError):
-    """Raised when a CLI flag has been completely removed in v2."""
+    """Raised when a v1 flag has been removed in v2."""
 
 
 class RedundantV1FlagError(UnsupportedV1FeatureError):
-    """Raised when a v1 flag is redundant in v2 because it's the default behavior."""
+    """Raised when a v1 flag is redundant in v2."""

html_to_markdown/options.py

@@ -6,38 +6,7 @@ This module provides dataclass-based configuration for the v2 API.
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Literal, Protocol
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from bs4 import Tag
-
-
-class ConverterFunction(Protocol):
-    """Protocol for custom converter functions.
-
-    Converter functions receive keyword-only arguments including the HTML tag,
-    processed text content, and any conversion options needed.
-
-    Example:
-        >>> def custom_link_converter(*, tag: Tag, text: str, autolinks: bool, **kwargs: Any) -> str:
-        ...     href = tag.get("href", "")
-        ...     return f"[{text}]({href})"
-    """
-
-    def __call__(self, *, tag: Tag, text: str, **kwargs: Any) -> str:
-        """Convert an HTML element to Markdown.
-
-        Args:
-            tag: BeautifulSoup Tag object representing the HTML element
-            text: Processed text content of the element's children
-            **kwargs: Additional conversion options (varies by converter)
-
-        Returns:
-            Markdown string representation of the element
-        """
-        ...
+from typing import Literal
 
 
 @dataclass
@@ -87,8 +56,8 @@ class ConversionOptions:
     code_language: str = ""
     """Default language for code blocks."""
 
-    code_language_callback: Callable[[Tag], str] | None = None
-    """Callback to determine code language from element."""
+    encoding: str = "utf-8"
+    """Character encoding expected for the HTML input."""
 
     autolinks: bool = True
     """Convert bare URLs to automatic links."""
@@ -102,15 +71,6 @@ class ConversionOptions:
     br_in_tables: bool = False
     """Use <br> tags for line breaks in table cells instead of spaces."""
 
-    hocr_extract_tables: bool = True
-    """Enable table extraction from hOCR (HTML-based OCR) documents."""
-
-    hocr_table_column_threshold: int = 50
-    """Pixel threshold for detecting column boundaries in hOCR tables."""
-
-    hocr_table_row_threshold_ratio: float = 0.5
-    """Row height ratio threshold for detecting row boundaries in hOCR tables."""
-
     highlight_style: Literal["double-equal", "html", "bold"] = "double-equal"
     """Style for highlighting <mark> elements."""
 
@@ -129,9 +89,6 @@ class ConversionOptions:
     wrap_width: int = 80
     """Column width for text wrapping."""
 
-    convert: set[str] | None = None
-    """HTML tags to convert to Markdown (None = all supported tags). v1 compatibility only."""
-
     strip_tags: set[str] | None = None
     """HTML tags to strip from output (output only text content, no markdown conversion)."""
 
@@ -150,9 +107,6 @@ class ConversionOptions:
     code_block_style: Literal["indented", "backticks", "tildes"] = "backticks"
     """Style for code blocks: 'backticks' (```, better whitespace preservation), 'indented' (4 spaces), or 'tildes' (~~~). All are CommonMark compliant."""
 
-    custom_converters: dict[str, Callable[..., str]] | None = None
-    """Custom converter functions for specific HTML elements."""
-
     debug: bool = False
     """Enable debug mode with diagnostic warnings about unhandled elements and hOCR processing."""
 
@@ -182,30 +136,3 @@ class PreprocessingOptions:
 
     remove_forms: bool = True
     """Remove form elements during preprocessing."""
-
-    excluded_navigation_classes: set[str] | None = None
-    """Navigation class fragments to keep even when removing navigation."""
-
-    extra_navigation_classes: set[str] | None = None
-    """Additional navigation class fragments to strip beyond defaults."""
-
-
-@dataclass
-class ParsingOptions:
-    """HTML parsing configuration.
-
-    Example:
-        >>> options = ParsingOptions(
-        ...     encoding="utf-8",
-        ...     detect_encoding=True,
-        ... )
-    """
-
-    encoding: str = "utf-8"
-    """Character encoding for decoding bytes input."""
-
-    detect_encoding: bool = False
-    """Attempt to detect encoding from HTML (not yet implemented)."""
-
-    parser: str | None = None
-    """HTML parser to use: 'html.parser', 'lxml', or 'html5lib' (None = auto)."""

html_to_markdown/v1_compat.py

@@ -1,21 +1,18 @@
 """V1 API compatibility layer.
 
 Provides backward compatibility for the v1 convert_to_markdown API
-by translating v1 kwargs to v2 ConversionOptions/PreprocessingOptions/ParsingOptions.
+by translating v1 kwargs to v2 ConversionOptions and PreprocessingOptions.
 """
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import warnings
 
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
-from html_to_markdown import ConversionOptions, ParsingOptions, PreprocessingOptions
+from html_to_markdown import ConversionOptions, PreprocessingOptions
 from html_to_markdown import convert as convert_v2
 
 
-def convert_to_markdown(  # noqa: D417
+def convert_to_markdown(
     html: str,
     *,
     heading_style: str = "underlined",
@@ -48,32 +45,72 @@ def convert_to_markdown(  # noqa: D417
     preprocessing_preset: str = "standard",
     remove_navigation: bool = True,
     remove_forms: bool = True,
-    parser: str = "html.parser",
     source_encoding: str = "utf-8",
     code_language_callback: object | None = None,
     strip: list[str] | None = None,
     convert: list[str] | None = None,
     custom_converters: dict[str, object] | None = None,
 ) -> str:
-    """Convert HTML to Markdown (v1 API compatibility).
-
-    This function provides backward compatibility with the v1 API by accepting
-    the same kwargs and translating them to v2 ConversionOptions.
+    """Convert HTML to Markdown (v1 compatibility API).
 
-    Note: Some v1 options are not supported in v2:
-    - code_language_callback: Removed in v2
-    - convert: Removed in v2
-    - custom_converters: Not yet implemented in v2
+    This function provides backward compatibility with the v1 API by translating
+    v1-style keyword arguments to v2 ConversionOptions and PreprocessingOptions.
 
     Args:
-        html: HTML string to convert
+        html: HTML string to convert.
+        heading_style: Style for headings (default: "underlined" for v1 compatibility).
+        list_indent_type: Type of indentation for lists.
+        list_indent_width: Number of spaces for list indentation (v1 default: 4).
+        bullets: Characters to use for unordered list bullets.
+        strong_em_symbol: Symbol for strong/emphasis formatting.
+        escape_asterisks: Escape asterisk characters (v1 default: True).
+        escape_underscores: Escape underscore characters (v1 default: True).
+        escape_misc: Escape miscellaneous Markdown characters (v1 default: True).
+        code_language: Default language for code blocks.
+        autolinks: Convert bare URLs to automatic links.
+        default_title: Add a default title if none exists.
+        br_in_tables: Use <br> tags for line breaks in table cells.
+        hocr_extract_tables: Deprecated - always True in v2.
+        hocr_table_column_threshold: Deprecated - uses built-in heuristics in v2.
+        hocr_table_row_threshold_ratio: Deprecated - uses built-in heuristics in v2.
+        highlight_style: Style for highlighting <mark> elements.
+        extract_metadata: Extract metadata from HTML head.
+        whitespace_mode: How to handle whitespace.
+        strip_newlines: Remove newlines from HTML before processing.
+        wrap: Enable text wrapping.
+        wrap_width: Column width for text wrapping.
+        convert_as_inline: Treat block elements as inline.
+        sub_symbol: Symbol for subscript text.
+        sup_symbol: Symbol for superscript text.
+        newline_style: Style for newlines.
+        keep_inline_images_in: Parent tag names where images should remain inline.
+        preprocess: Enable HTML preprocessing.
+        preprocessing_preset: Preprocessing aggressiveness level.
+        remove_navigation: Remove navigation elements during preprocessing.
+        remove_forms: Remove form elements during preprocessing.
+        source_encoding: Character encoding expected for the HTML input.
+        code_language_callback: Deprecated - not supported in v2.
+        strip: HTML tags to strip from output.
+        convert: Deprecated - not supported in v2.
+        custom_converters: Deprecated - not yet implemented in v2.
 
     Returns:
-        Markdown string
+        Converted Markdown string.
 
     Raises:
-        NotImplementedError: If unsupported v1 options are provided
+        NotImplementedError: If deprecated v1 features are used.
+
+    .. deprecated:: 2.0
+        Use :func:`html_to_markdown.convert` with :class:`ConversionOptions` instead.
+        The v1 API is provided for backward compatibility only.
     """
+    warnings.warn(
+        "convert_to_markdown() is deprecated and will be removed in v3.0. "
+        "Use html_to_markdown.convert() with ConversionOptions instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     if code_language_callback is not None:
         raise NotImplementedError(
             "code_language_callback was removed in v2. Use the code_language option to set a default language."
@@ -82,9 +119,17 @@ def convert_to_markdown(  # noqa: D417
         raise NotImplementedError("convert option was removed in v2. All supported tags are converted by default.")
     if custom_converters is not None:
         raise NotImplementedError("custom_converters is not yet implemented in v2")
+    if not hocr_extract_tables:
+        raise NotImplementedError(
+            "hocr_extract_tables toggle was removed in v2. hOCR tables are always reconstructed when detected."
+        )
+    if hocr_table_column_threshold != 50 or hocr_table_row_threshold_ratio != 0.5:
+        raise NotImplementedError(
+            "hOCR table threshold overrides were removed in v2. Table reconstruction now uses built-in heuristics."
+        )
 
-    # V1 behavior: if code_language is set, use fenced code blocks (backticks)
-    # V2 default is indented code blocks, so we need to override
+    # ~keep: v1 used indented code blocks by default, but switched to backticks when a language was set
+    # This maintains v1 behavior for backward compatibility
     code_block_style = "backticks" if code_language else "indented"
 
     options = ConversionOptions(
@@ -101,9 +146,6 @@ def convert_to_markdown(  # noqa: D417
         autolinks=autolinks,
         default_title=default_title,
         br_in_tables=br_in_tables,
-        hocr_extract_tables=hocr_extract_tables,
-        hocr_table_column_threshold=hocr_table_column_threshold,
-        hocr_table_row_threshold_ratio=hocr_table_row_threshold_ratio,
         highlight_style=highlight_style,  # type: ignore[arg-type]
         extract_metadata=extract_metadata,
         whitespace_mode=whitespace_mode,  # type: ignore[arg-type]
@@ -125,37 +167,23 @@ def convert_to_markdown(  # noqa: D417
         remove_forms=remove_forms,
     )
 
-    parsing = ParsingOptions(
-        encoding=source_encoding,
-        parser=parser,
-    )
-
-    return convert_v2(html, options, preprocessing, parsing)
-
+    options.encoding = source_encoding
+    return convert_v2(html, options, preprocessing)
 
-def convert_to_markdown_stream(  # noqa: D417
-    html: str,
-    *,
-    chunk_size: int = 4096,
-    **kwargs: object,
-) -> Iterator[str]:
-    """Stream HTML to Markdown conversion (v1 API).
 
-    Note: Streaming was removed in v2.
+def markdownify(*args: object, **kwargs: object) -> str:
+    """Alias for convert_to_markdown (deprecated).
 
-    Args:
-        html: HTML string to convert
-        chunk_size: Size of chunks to yield (not used in v2)
-
-    Raises:
-        NotImplementedError: Streaming was removed in v2
+    .. deprecated:: 2.0
+        Use html_to_markdown.convert() instead.
     """
-    raise NotImplementedError(
-        "Streaming API (convert_to_markdown_stream) was removed in v2 (html5ever does not support streaming). "
-        "Use convert_to_markdown() instead."
+    warnings.warn(
+        "markdownify() is deprecated and will be removed in v3.0. "
+        "Use html_to_markdown.convert() with ConversionOptions instead.",
+        DeprecationWarning,
+        stacklevel=2,
     )
+    return convert_to_markdown(*args, **kwargs)  # type: ignore[arg-type]
 
 
-markdownify = convert_to_markdown
-
-__all__ = ["convert_to_markdown", "convert_to_markdown_stream", "markdownify"]
+__all__ = ["convert_to_markdown", "markdownify"]

html_to_markdown-2.1.2.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: html-to-markdown
+Version: 2.1.2
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Typing :: Typed
+License-File: LICENSE
+Summary: High-performance HTML to Markdown converter powered by Rust with a clean Python API
+Keywords: cli-tool,converter,html,html2markdown,html5,markdown,markup,parser,rust,text-processing
+Home-Page: https://github.com/Goldziher/html-to-markdown
+Author-email: Na'aman Hirschfeld <nhirschfeld@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/Goldziher/html-to-markdown/releases
+Project-URL: Homepage, https://github.com/Goldziher/html-to-markdown
+Project-URL: Issues, https://github.com/Goldziher/html-to-markdown/issues
+Project-URL: Repository, https://github.com/Goldziher/html-to-markdown.git
+
+# html-to-markdown
+
+High-performance HTML to Markdown converter with a clean Python API (powered by a Rust core). Wheels are published for Linux, macOS, and Windows.
+
+[![PyPI version](https://badge.fury.io/py/html-to-markdown.svg)](https://github.com/Goldziher/html-to-markdown)
+[![Rust crate](https://img.shields.io/crates/v/html-to-markdown-rs.svg)](https://github.com/Goldziher/html-to-markdown)
+[![Python Versions](https://img.shields.io/pypi/pyversions/html-to-markdown.svg)](https://github.com/Goldziher/html-to-markdown)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/Goldziher/html-to-markdown/blob/main/LICENSE)
+
+## Installation
+
+```bash
+pip install html-to-markdown
+```
+
+## Performance Snapshot
+
+Apple M4 • Real Wikipedia documents • `convert()` (Python)
+
+| Document            | Size  | Latency | Throughput | Docs/sec |
+| ------------------- | ----- | ------- | ---------- | -------- |
+| Lists (Timeline)    | 129KB | 0.62ms  | 208 MB/s   | 1,613    |
+| Tables (Countries)  | 360KB | 2.02ms  | 178 MB/s   | 495      |
+| Mixed (Python wiki) | 656KB | 4.56ms  | 144 MB/s   | 219      |
+
+> V1 averaged ~2.5 MB/s (Python/BeautifulSoup). V2’s Rust engine delivers 60–80× higher throughput.
+
+## Quick Start
+
+```python
+from html_to_markdown import convert
+
+html = """
+<h1>Welcome</h1>
+<p>This is <strong>fast</strong> Rust-powered conversion!</p>
+<ul>
+    <li>Blazing fast</li>
+    <li>Type safe</li>
+    <li>Easy to use</li>
+</ul>
+"""
+
+markdown = convert(html)
+print(markdown)
+```
+
+## Configuration (v2 API)
+
+```python
+from html_to_markdown import ConversionOptions, convert
+
+options = ConversionOptions(
+    heading_style="atx",
+    list_indent_width=2,
+    bullets="*+-",
+)
+options.escape_asterisks = True
+options.code_language = "python"
+options.extract_metadata = True
+
+markdown = convert(html, options)
+```
+
+### HTML Preprocessing
+
+```python
+from html_to_markdown import ConversionOptions, PreprocessingOptions, convert
+
+options = ConversionOptions(
+    preprocessing=PreprocessingOptions(enabled=True, preset="aggressive"),
+)
+
+markdown = convert(scraped_html, options)
+```
+
+### Inline Image Extraction
+
+```python
+from html_to_markdown import InlineImageConfig, convert_with_inline_images
+
+markdown, inline_images, warnings = convert_with_inline_images(
+    '<p><img src="data:image/png;base64,...==" alt="Pixel" width="1" height="1"></p>',
+    image_config=InlineImageConfig(max_decoded_size_bytes=1024, infer_dimensions=True),
+)
+
+if inline_images:
+    first = inline_images[0]
+    print(first["format"], first["dimensions"], first["attributes"])  # e.g. "png", (1, 1), {"width": "1"}
+```
+
+Each inline image is returned as a typed dictionary (`bytes` payload, metadata, and relevant HTML attributes). Warnings are human-readable skip reasons.
+
+### hOCR (HTML OCR) Support
+
+```python
+from html_to_markdown import ConversionOptions, convert
+
+# Default: emit structured Markdown directly
+markdown = convert(hocr_html)
+
+# hOCR documents are detected automatically; tables are reconstructed without extra configuration.
+markdown = convert(hocr_html)
+```
+
+## CLI (same engine)
+
+```bash
+pipx install html-to-markdown  # or: pip install html-to-markdown
+
+html-to-markdown page.html > page.md
+cat page.html | html-to-markdown --heading-style atx > page.md
+```
+
+## API Surface
+
+### `ConversionOptions`
+
+Key fields (see docstring for full matrix):
+
+- `heading_style`: `"underlined" | "atx" | "atx_closed"`
+- `list_indent_width`: spaces per indent level (default 2)
+- `bullets`: cycle of bullet characters (`"*+-"`)
+- `strong_em_symbol`: `"*"` or `"_"`
+- `code_language`: default fenced code block language
+- `wrap`, `wrap_width`: wrap Markdown output
+- `strip_tags`: remove specific HTML tags
+- `preprocessing`: `PreprocessingOptions`
+- `encoding`: input character encoding (informational)
+
+### `PreprocessingOptions`
+
+- `enabled`: enable HTML sanitisation
+- `preset`: `"minimal" | "standard" | "aggressive"`
+- `remove_navigation`, `remove_forms`
+
+### `InlineImageConfig`
+
+- `max_decoded_size_bytes`: reject larger payloads
+- `filename_prefix`: generated name prefix (`embedded_image` default)
+- `capture_svg`: collect inline `<svg>` (default `True`)
+- `infer_dimensions`: decode raster images to obtain dimensions (default `False`)
+
+## v1 Compatibility
+
+- **Performance**: V1 averaged ~2.5 MB/s; V2 sustains 150–210 MB/s with identical Markdown output.
+- **Compat shim**: `html_to_markdown.v1_compat` exposes `convert_to_markdown`, `convert_to_markdown_stream`, and `markdownify` to ease migration. Keyword mappings are listed in the [changelog](CHANGELOG.md#v200).
+- **CLI**: The Rust CLI replaces the Python script. New flags are documented via `html-to-markdown --help`.
+- **Removed options**: `code_language_callback`, `strip`, and streaming APIs were removed; use `ConversionOptions`, `PreprocessingOptions`, and the inline-image helpers instead.
+
+## Links
+
+- GitHub: [https://github.com/Goldziher/html-to-markdown](https://github.com/Goldziher/html-to-markdown)
+- Discord: [https://discord.gg/pXxagNK2zN](https://discord.gg/pXxagNK2zN)
+- Kreuzberg ecosystem: [https://kreuzberg.dev](https://kreuzberg.dev)
+
+## License
+
+MIT License – see [LICENSE](https://github.com/Goldziher/html-to-markdown/blob/main/LICENSE).
+
+## Support
+
+If you find this library useful, consider [sponsoring the project](https://github.com/sponsors/Goldziher).
+

html_to_markdown-2.1.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+html_to_markdown-2.1.2.data/scripts/html-to-markdown.exe,sha256=SJCBlZp0uTo6_wzS7KEgXariZtABUVc64o5TVxOwVZo,4414976
+html_to_markdown-2.1.2.dist-info/METADATA,sha256=TgFH9djK4HzJF_vDFVZCm7EDXYscA4v9t31DuXCujIE,7233
+html_to_markdown-2.1.2.dist-info/WHEEL,sha256=4EDp_7DiFfWl1yYv5M4wSosAn5L_xgD1dyrQxQxfCx8,95
+html_to_markdown-2.1.2.dist-info/licenses/LICENSE,sha256=QhKFMkQLa4mSUlOsyG9VElzC7GYbAKtiS_EwOCyH-b4,1107
+html_to_markdown/__init__.py,sha256=3_Egcf46oNcEam7rc7zAHx8lfOj1eVNO1p0kErVf_fs,1191
+html_to_markdown/__main__.py,sha256=5objj9lB7hhpSpZsDok5tv9o9yztVR63Ccww-pXsAyY,343
+html_to_markdown/_html_to_markdown.pyd,sha256=ES7QEe9lTb2ZK3yvC2-vNHng__U7HB3CY5p2wJ0IuNQ,4159488
+html_to_markdown/_rust.pyi,sha256=SHrrT8opJd5kcRYycooR4AS9is5tr1beSGtpoUWqzNc,2097
+html_to_markdown/api.py,sha256=YQQuJoO1OQnXpuOLk8TbdQDTARcKYFbf_zSA44BeHCM,2800
+html_to_markdown/bin/html-to-markdown.exe,sha256=SJCBlZp0uTo6_wzS7KEgXariZtABUVc64o5TVxOwVZo,4414976
+html_to_markdown/cli.py,sha256=z59l8sF8wIRRzJtUd-tXgqiC0WTqkTjzl-df8Ey_oQ0,67
+html_to_markdown/cli_proxy.py,sha256=J2Qk9MnnkFKIroxc0wn79nzI0dXqXDDNEAF9o9hth9Y,3829
+html_to_markdown/exceptions.py,sha256=31VqpPi4JLGv7lI2481Z4f2s5ejYmq97c3s-WFFkXVU,2443
+html_to_markdown/options.py,sha256=ijjRBTwrbESbwmYTOXV_ZO1A1GAmOzzILiFoPeC-jZk,4940
+html_to_markdown/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+html_to_markdown/v1_compat.py,sha256=Lb3pppLfVH9EyAYGbOfpcO3vYkof4SIYDMI-CBEbh-A,8045
+html_to_markdown-2.1.2.dist-info/RECORD,,

html_to_markdown-2.0.1.dist-info/METADATA

@@ -1,243 +0,0 @@
-Metadata-Version: 2.4
-Name: html-to-markdown
-Version: 2.0.1
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Rust
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing
-Classifier: Topic :: Text Processing :: Markup
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Classifier: Topic :: Text Processing :: Markup :: Markdown
-Classifier: Typing :: Typed
-License-File: LICENSE
-Summary: High-performance HTML to Markdown converter powered by Rust with a clean Python API
-Keywords: cli-tool,converter,html,html2markdown,html5,markdown,markup,parser,rust,text-processing
-Home-Page: https://github.com/Goldziher/html-to-markdown
-Author-email: Na'aman Hirschfeld <nhirschfeld@gmail.com>
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Changelog, https://github.com/Goldziher/html-to-markdown/releases
-Project-URL: Homepage, https://github.com/Goldziher/html-to-markdown
-Project-URL: Issues, https://github.com/Goldziher/html-to-markdown/issues
-Project-URL: Repository, https://github.com/Goldziher/html-to-markdown.git
-
-# html-to-markdown
-
-High-performance HTML to Markdown converter powered by Rust with a clean Python API. Available via PyPI with pre-built wheels for all major platforms.
-
-[![PyPI version](https://badge.fury.io/py/html-to-markdown.svg)](https://pypi.org/project/html-to-markdown/)
-[![Crates.io](https://img.shields.io/crates/v/html-to-markdown-rs.svg)](https://crates.io/crates/html-to-markdown-rs)
-[![Python Versions](https://img.shields.io/pypi/pyversions/html-to-markdown.svg)](https://pypi.org/project/html-to-markdown/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Discord](https://img.shields.io/badge/Discord-Join%20our%20community-7289da)](https://discord.gg/pXxagNK2zN)
-
-Part of the [Kreuzberg](https://kreuzberg.dev) ecosystem for document intelligence.
-
-## Installation
-
-```bash
-pip install html-to-markdown
-```
-
-Pre-built wheels available for:
-
-- **Linux**: x86_64, aarch64
-- **macOS**: x86_64 (Intel), arm64 (Apple Silicon)
-- **Windows**: x86_64
-
-## ⚡ Performance
-
-Real Wikipedia documents on Apple M4:
-
-| Document            | Size  | Latency | Throughput | Docs/sec |
-| ------------------- | ----- | ------- | ---------- | -------- |
-| Lists (Timeline)    | 129KB | 0.62ms  | 208 MB/s   | 1,613    |
-| Tables (Countries)  | 360KB | 2.02ms  | 178 MB/s   | 495      |
-| Mixed (Python wiki) | 656KB | 4.56ms  | 144 MB/s   | 219      |
-
-**19-30x faster** than pure Python implementations.
-
-## Quick Start
-
-```python
-from html_to_markdown import convert_to_markdown
-
-html = """
-<h1>Welcome</h1>
-<p>This is <strong>fast</strong> Rust-powered conversion!</p>
-<ul>
-    <li>Blazing fast</li>
-    <li>Type safe</li>
-    <li>Easy to use</li>
-</ul>
-"""
-
-markdown = convert_to_markdown(html)
-print(markdown)
-```
-
-Output:
-
-```markdown
-# Welcome
-
-This is **fast** Rust-powered conversion!
-
-- Blazing fast
-- Type safe
-- Easy to use
-```
-
-## Configuration
-
-```python
-from html_to_markdown import convert_to_markdown
-
-markdown = convert_to_markdown(
-    html,
-    heading_style="atx",  # "atx", "atx_closed", "underlined"
-    list_indent_width=2,  # Discord/Slack: use 2
-    bullets="*+-",  # Bullet characters
-    strong_em_symbol="*",  # "*" or "_"
-    escape_asterisks=True,  # Escape * in text
-    code_language="python",  # Default code block language
-    extract_metadata=True,  # Extract HTML metadata
-)
-```
-
-### HTML Preprocessing
-
-Clean web-scraped HTML before conversion:
-
-```python
-from html_to_markdown import convert_to_markdown
-
-markdown = convert_to_markdown(
-    scraped_html,
-    preprocess=True,
-    preprocessing_preset="aggressive",  # "minimal", "standard", "aggressive"
-)
-```
-
-## Features
-
-- **🚀 Blazing Fast**: Pure Rust core with ultra-fast `tl` HTML parser
-- **🐍 Type Safe**: Full type hints and `.pyi` stubs for excellent IDE support
-- **📊 hOCR 1.2 Compliant**: Full support for all 40+ elements and 20+ properties
-- **📝 CommonMark Compliant**: Follows CommonMark specification for list formatting
-- **🌍 Cross-Platform**: Pre-built wheels for Linux, macOS, and Windows
-- **✅ Well-Tested**: 900+ tests with dual Python + Rust coverage
-- **🔧 Zero Dependencies**: No BeautifulSoup or lxml required
-
-## hOCR 1.2 Support
-
-Complete hOCR 1.2 specification compliance with support for all elements, properties, and metadata:
-
-```python
-from html_to_markdown import convert_to_markdown
-
-# Option 1: Document structure extraction (NEW in v2)
-# Extracts all hOCR elements and converts to structured markdown
-markdown = convert_to_markdown(hocr_html)
-
-# Option 2: Legacy table extraction (spatial reconstruction)
-# Reconstructs tables from word bounding boxes
-markdown = convert_to_markdown(
-    hocr_html,
-    hocr_extract_tables=True,
-    hocr_table_column_threshold=50,
-    hocr_table_row_threshold_ratio=0.5,
-)
-```
-
-**Full hOCR 1.2 Spec Coverage:**
-
-- ✅ **All 40 Element Types** - Logical structure, typesetting, floats, inline, engine-specific
-- ✅ **All 20+ Properties** - bbox, baseline, textangle, poly, x_wconf, x_font, x_fsize, and more
-- ✅ **All 5 Metadata Fields** - ocr-system, ocr-capabilities, ocr-number-of-pages, ocr-langs, ocr-scripts
-
-## Configuration Reference
-
-### ConversionOptions
-
-| Option                           | Type  | Default       | Description                                                             |
-| -------------------------------- | ----- | ------------- | ----------------------------------------------------------------------- |
-| `heading_style`                  | str   | `"atx"`       | Heading format: `"atx"` (#), `"atx_closed"` (# #), `"underlined"` (===) |
-| `list_indent_width`              | int   | `2`           | Spaces per list indent level (CommonMark: 2)                            |
-| `list_indent_type`               | str   | `"spaces"`    | `"spaces"` or `"tabs"`                                                  |
-| `bullets`                        | str   | `"*+-"`       | Bullet chars for unordered lists (cycles through levels)                |
-| `strong_em_symbol`               | str   | `"*"`         | Symbol for bold/italic: `"*"` or `"_"`                                  |
-| `escape_asterisks`               | bool  | `True`        | Escape `*` in text                                                      |
-| `escape_underscores`             | bool  | `True`        | Escape `_` in text                                                      |
-| `code_language`                  | str   | `""`          | Default language for code blocks                                        |
-| `code_block_style`               | str   | `"backticks"` | `"indented"` (4 spaces), `"backticks"` (\`\`\`), `"tildes"` (\~~~)      |
-| `extract_metadata`               | bool  | `True`        | Extract HTML metadata as comment                                        |
-| `hocr_extract_tables`            | bool  | `True`        | Enable hOCR table extraction                                            |
-| `hocr_table_column_threshold`    | int   | `50`          | Column detection threshold (pixels)                                     |
-| `hocr_table_row_threshold_ratio` | float | `0.5`         | Row grouping threshold ratio                                            |
-
-### Preprocessing Options
-
-| Option                 | Type | Default      | Description                               |
-| ---------------------- | ---- | ------------ | ----------------------------------------- |
-| `preprocess`           | bool | `False`      | Enable HTML preprocessing                 |
-| `preprocessing_preset` | str  | `"standard"` | `"minimal"`, `"standard"`, `"aggressive"` |
-
-## CLI Tool
-
-A native Rust CLI binary is also available:
-
-```bash
-# Install via pipx (recommended for CLI tools)
-pipx install html-to-markdown
-
-# Or install with pip
-pip install html-to-markdown
-
-# Use the CLI
-html-to-markdown input.html > output.md
-echo "<h1>Test</h1>" | html-to-markdown
-```
-
-**For Rust library usage and comprehensive documentation**, see the [GitHub repository](https://github.com/Goldziher/html-to-markdown).
-
-## Upgrading from v1.x
-
-All v1 code works without changes. v2 is a complete Rust rewrite with **19-30x performance improvements**:
-
-**What Changed:**
-
-- Complete Rust rewrite using `tl` HTML parser
-- CommonMark-compliant defaults (2-space indents, minimal escaping, ATX headings)
-- No BeautifulSoup or lxml dependencies
-
-**Removed Features:**
-
-- `code_language_callback` - use `code_language` for default language
-- `strip` / `convert` options - use preprocessing instead
-- `convert_to_markdown_stream()` - not supported in v2
-
-## Links
-
-- **GitHub Repository**: [https://github.com/Goldziher/html-to-markdown](https://github.com/Goldziher/html-to-markdown)
-- **Rust Crate**: [https://crates.io/crates/html-to-markdown-rs](https://crates.io/crates/html-to-markdown-rs)
-- **Discord Community**: [https://discord.gg/pXxagNK2zN](https://discord.gg/pXxagNK2zN)
-- **Kreuzberg Ecosystem**: [https://kreuzberg.dev](https://kreuzberg.dev)
-
-## License
-
-MIT License - see [LICENSE](https://github.com/Goldziher/html-to-markdown/blob/main/LICENSE) for details.
-
-## Support
-
-If you find this library useful, consider [sponsoring the project](https://github.com/sponsors/Goldziher).
-

html_to_markdown-2.0.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-html_to_markdown-2.0.1.data/scripts/html-to-markdown.exe,sha256=4IXz5ITYrahD_3Qze4ldQ1R9AdrxiEO9xWF56VnaMJE,4380672
-html_to_markdown-2.0.1.dist-info/METADATA,sha256=altO23YUZgJVPuW2sbzObGYEQAWS9MDDkAPMIZjlHWg,10057
-html_to_markdown-2.0.1.dist-info/WHEEL,sha256=4EDp_7DiFfWl1yYv5M4wSosAn5L_xgD1dyrQxQxfCx8,95
-html_to_markdown-2.0.1.dist-info/licenses/LICENSE,sha256=QhKFMkQLa4mSUlOsyG9VElzC7GYbAKtiS_EwOCyH-b4,1107
-html_to_markdown/__init__.py,sha256=c8bbkGkjR0bQs9ZZzhNevTULM4vzQIDXv3aaHSfVtmQ,1314
-html_to_markdown/__main__.py,sha256=5objj9lB7hhpSpZsDok5tv9o9yztVR63Ccww-pXsAyY,343
-html_to_markdown/_html_to_markdown.pyd,sha256=djqk4pMy4X6ioYreksFwKsmAtGuZzhBNhg2Mtw4AcPM,3401216
-html_to_markdown/_rust.pyi,sha256=bA1lfF_pRWpMFXApXVl7VXUcV1q8-T4-jVrEqLDwJ1Y,2220
-html_to_markdown/api.py,sha256=HfxYYebne2bZU62a-VALhurWfqDy5PEfUYNVnU6suac,3720
-html_to_markdown/bin/html-to-markdown.exe,sha256=4IXz5ITYrahD_3Qze4ldQ1R9AdrxiEO9xWF56VnaMJE,4380672
-html_to_markdown/cli.py,sha256=4bQ44HhOKtQJY9t-TjSul-J7pqSHEpg9NKtZ0AeAqZA,263
-html_to_markdown/cli_proxy.py,sha256=mq-1BTjnr380N-mCU4cx8DyTIbY6ycq-_2DA10sLlfk,4442
-html_to_markdown/exceptions.py,sha256=L2YmpDWsvxTu2b-M_oT3mQdyyNhDM1jsvdWr18ZvD2Q,2707
-html_to_markdown/options.py,sha256=cenv2-vwduteQdIt6IXqDD0JyRFfa05oqhWgxKVdlB4,7452
-html_to_markdown/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-html_to_markdown/v1_compat.py,sha256=Qts9BqmWMcZt5CZ8P20_vf8oc43tMgZxkj3-W0YI2VE,5682
-html_to_markdown-2.0.1.dist-info/RECORD,,