unpdf-markdown 0.13.0__tar.gz

unpdf_markdown-0.13.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: unpdf-markdown
+Version: 0.13.0
+Summary: Python bindings for unpdf - High-performance PDF content extraction
+Author: iyulab
+License: MIT
+Project-URL: Homepage, https://github.com/iyulab/unpdf
+Project-URL: Documentation, https://github.com/iyulab/unpdf
+Project-URL: Repository, https://github.com/iyulab/unpdf
+Project-URL: Issues, https://github.com/iyulab/unpdf/issues
+Keywords: pdf,markdown,text-extraction,document,parser
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# unpdf
+
+Python bindings for [unpdf](https://github.com/iyulab/unpdf) - High-performance PDF content extraction to Markdown, text, and JSON.
+
+## Installation
+
+```bash
+pip install unpdf-markdown
+```
+
+The distribution is `unpdf-markdown`; the import name is `unpdf`.
+
+## Quick Start
+
+```python
+import unpdf
+
+# Convert PDF to Markdown
+markdown = unpdf.to_markdown("document.pdf")
+print(markdown)
+
+# Convert PDF to plain text
+text = unpdf.to_text("document.pdf")
+print(text)
+
+# Convert PDF to JSON
+json_data = unpdf.to_json("document.pdf", pretty=True)
+print(json_data)
+
+# Get document information
+info = unpdf.get_info("document.pdf")
+print(info)
+
+# Get page count
+pages = unpdf.get_page_count("document.pdf")
+print(f"Total pages: {pages}")
+
+# Check if file is a valid PDF
+is_valid = unpdf.is_pdf("document.pdf")
+print(f"Is valid PDF: {is_valid}")
+```
+
+## Input: path or bytes
+
+Every function takes its PDF as `PdfSource` — a path (`str`, or any `os.PathLike`
+such as `pathlib.Path`) or the PDF's own bytes. Types are unambiguous: `str` is
+always a path, `bytes` is always content, and bytes go through the native
+in-memory parser rather than a temporary file.
+
+```python
+from pathlib import Path
+import unpdf
+
+unpdf.to_markdown("document.pdf")
+unpdf.to_markdown(Path("document.pdf"))
+unpdf.to_markdown(pdf_bytes)
+```
+
+## API Reference
+
+### `to_markdown(source: PdfSource, flags: int = 0) -> str`
+Convert a PDF file to Markdown format. `flags` is a bitwise OR of:
+
+| Constant | Effect |
+|---|---|
+| `UNPDF_FLAG_FRONTMATTER` | Emit YAML frontmatter with document metadata |
+| `UNPDF_FLAG_ESCAPE_SPECIAL` | Escape Markdown special characters |
+| `UNPDF_FLAG_PAGE_MARKERS` | Mark each page boundary with `<!-- page N -->` |
+
+```python
+import unpdf
+
+markdown = unpdf.to_markdown(
+    "document.pdf",
+    unpdf.UNPDF_FLAG_FRONTMATTER | unpdf.UNPDF_FLAG_PAGE_MARKERS,
+)
+```
+
+### `to_text(source: PdfSource) -> str`
+Convert a PDF file to plain text.
+
+### `to_json(source: PdfSource, pretty: bool = False) -> str`
+Convert a PDF file to JSON format.
+
+### `get_info(source: PdfSource) -> dict`
+Get document metadata. Keys: `section_count` (the page count), `resource_count`,
+plus `title` / `author` only when the document sets them.
+
+### `get_page_count(source: PdfSource) -> int`
+Get the number of pages in a PDF file.
+
+### `is_pdf(source: PdfSource) -> bool`
+Check if a file is a valid PDF.
+
+### `version() -> str`
+Get the version of the native library.
+
+### `get_extraction_quality(source: PdfSource) -> dict`
+Document-level extraction diagnostics: `char_count`, `word_count`,
+`replacement_char_count`, `encrypted`, `is_scan_pdf`, `suppressed_ocr_pages`,
+`suppressed_text_runs`,
+`pages_incomplete`, `declared_page_count`, `unresolved_page_nodes`,
+`skipped_object_count`. See "Incomplete extraction" below.
+
+### `get_page_stats(source: PdfSource, page_number: int) -> dict`
+Per-page content-stream operator counts (1-indexed): `page`, `text_op_count`,
+`image_op_count`, `ocr_text_suppressed`.
+
+## Detecting scanned (image-only) PDFs
+
+Empty output can mean a scanned document, a genuinely blank page, or a parse
+failure. The introspection surface tells them apart:
+
+```python
+import unpdf
+
+if unpdf.get_extraction_quality("scan.pdf")["is_scan_pdf"]:
+    print("Scanned document - OCR required")
+
+stats = unpdf.get_page_stats("scan.pdf", 1)
+if stats["text_op_count"] == 0 and stats["image_op_count"] > 0:
+    print("Page 1 is image-only (scanned)")
+elif stats["text_op_count"] == 0:
+    print("Page 1 is genuinely blank")
+```
+
+Note: a *searchable* scan (page image plus an invisible OCR text layer) reports
+`text_op_count > 0` — combine the check with `ocr_text_suppressed`, which flags
+pages whose unreadable OCR layer was dropped.
+
+## Incomplete extraction
+
+A damaged PDF does not always fail. When the cross-reference table survives but the
+objects it points at do not, the parser returns the pages it could read — a success
+over an incomplete page set. Check before indexing or archiving, because a page that
+silently never arrived is indistinguishable from a page that never existed:
+
+```python
+quality = unpdf.get_extraction_quality("document.pdf")
+if quality["pages_incomplete"]:
+    print(f"incomplete - document declares {quality['declared_page_count']} page(s)")
+```
+
+| Field | Meaning |
+|-------|---------|
+| `pages_incomplete` | Pages are known to be missing. The one field to branch on. |
+| `declared_page_count` | Page count the document declares, or `None` if unreadable. |
+| `unresolved_page_nodes` | Unreadable page-tree *nodes* — non-zero means incomplete, **not** a page count. |
+| `skipped_object_count` | Objects that could not be loaded. Most cost no page. |
+
+Also note that `get_info()["resource_count"]` counts the extracted-resource
+inventory, which this binding's parse path leaves empty (resource extraction is off
+by default to bound peak memory) — it is not a count of images on the page. Use
+`get_page_stats` for scan detection.
+
+## Handling failures
+
+`UnpdfError` carries a `kind` so you can branch on the reason a call failed instead
+of matching on message text:
+
+```python
+from unpdf import to_text, ErrorKind, UnpdfError
+
+try:
+    text = to_text("document.pdf")
+except UnpdfError as e:
+    if e.kind == ErrorKind.ENCRYPTED:
+        print("Password required")
+    elif e.kind in (ErrorKind.CORRUPTED, ErrorKind.PDF_PARSE):
+        print("The file is damaged")
+    else:
+        print(f"Extraction failed ({e.kind.name}): {e}")
+```
+
+`UnpdfError` subclasses `RuntimeError`, so existing `except RuntimeError` handlers
+keep working. `ErrorKind` values are part of the native ABI: new reasons take new
+numbers and existing ones are never renumbered, so treat an unrecognised value as a
+generic failure.
+
+## License
+
+MIT License

unpdf_markdown-0.13.0/README.md

@@ -0,0 +1,182 @@
+# unpdf
+
+Python bindings for [unpdf](https://github.com/iyulab/unpdf) - High-performance PDF content extraction to Markdown, text, and JSON.
+
+## Installation
+
+```bash
+pip install unpdf-markdown
+```
+
+The distribution is `unpdf-markdown`; the import name is `unpdf`.
+
+## Quick Start
+
+```python
+import unpdf
+
+# Convert PDF to Markdown
+markdown = unpdf.to_markdown("document.pdf")
+print(markdown)
+
+# Convert PDF to plain text
+text = unpdf.to_text("document.pdf")
+print(text)
+
+# Convert PDF to JSON
+json_data = unpdf.to_json("document.pdf", pretty=True)
+print(json_data)
+
+# Get document information
+info = unpdf.get_info("document.pdf")
+print(info)
+
+# Get page count
+pages = unpdf.get_page_count("document.pdf")
+print(f"Total pages: {pages}")
+
+# Check if file is a valid PDF
+is_valid = unpdf.is_pdf("document.pdf")
+print(f"Is valid PDF: {is_valid}")
+```
+
+## Input: path or bytes
+
+Every function takes its PDF as `PdfSource` — a path (`str`, or any `os.PathLike`
+such as `pathlib.Path`) or the PDF's own bytes. Types are unambiguous: `str` is
+always a path, `bytes` is always content, and bytes go through the native
+in-memory parser rather than a temporary file.
+
+```python
+from pathlib import Path
+import unpdf
+
+unpdf.to_markdown("document.pdf")
+unpdf.to_markdown(Path("document.pdf"))
+unpdf.to_markdown(pdf_bytes)
+```
+
+## API Reference
+
+### `to_markdown(source: PdfSource, flags: int = 0) -> str`
+Convert a PDF file to Markdown format. `flags` is a bitwise OR of:
+
+| Constant | Effect |
+|---|---|
+| `UNPDF_FLAG_FRONTMATTER` | Emit YAML frontmatter with document metadata |
+| `UNPDF_FLAG_ESCAPE_SPECIAL` | Escape Markdown special characters |
+| `UNPDF_FLAG_PAGE_MARKERS` | Mark each page boundary with `<!-- page N -->` |
+
+```python
+import unpdf
+
+markdown = unpdf.to_markdown(
+    "document.pdf",
+    unpdf.UNPDF_FLAG_FRONTMATTER | unpdf.UNPDF_FLAG_PAGE_MARKERS,
+)
+```
+
+### `to_text(source: PdfSource) -> str`
+Convert a PDF file to plain text.
+
+### `to_json(source: PdfSource, pretty: bool = False) -> str`
+Convert a PDF file to JSON format.
+
+### `get_info(source: PdfSource) -> dict`
+Get document metadata. Keys: `section_count` (the page count), `resource_count`,
+plus `title` / `author` only when the document sets them.
+
+### `get_page_count(source: PdfSource) -> int`
+Get the number of pages in a PDF file.
+
+### `is_pdf(source: PdfSource) -> bool`
+Check if a file is a valid PDF.
+
+### `version() -> str`
+Get the version of the native library.
+
+### `get_extraction_quality(source: PdfSource) -> dict`
+Document-level extraction diagnostics: `char_count`, `word_count`,
+`replacement_char_count`, `encrypted`, `is_scan_pdf`, `suppressed_ocr_pages`,
+`suppressed_text_runs`,
+`pages_incomplete`, `declared_page_count`, `unresolved_page_nodes`,
+`skipped_object_count`. See "Incomplete extraction" below.
+
+### `get_page_stats(source: PdfSource, page_number: int) -> dict`
+Per-page content-stream operator counts (1-indexed): `page`, `text_op_count`,
+`image_op_count`, `ocr_text_suppressed`.
+
+## Detecting scanned (image-only) PDFs
+
+Empty output can mean a scanned document, a genuinely blank page, or a parse
+failure. The introspection surface tells them apart:
+
+```python
+import unpdf
+
+if unpdf.get_extraction_quality("scan.pdf")["is_scan_pdf"]:
+    print("Scanned document - OCR required")
+
+stats = unpdf.get_page_stats("scan.pdf", 1)
+if stats["text_op_count"] == 0 and stats["image_op_count"] > 0:
+    print("Page 1 is image-only (scanned)")
+elif stats["text_op_count"] == 0:
+    print("Page 1 is genuinely blank")
+```
+
+Note: a *searchable* scan (page image plus an invisible OCR text layer) reports
+`text_op_count > 0` — combine the check with `ocr_text_suppressed`, which flags
+pages whose unreadable OCR layer was dropped.
+
+## Incomplete extraction
+
+A damaged PDF does not always fail. When the cross-reference table survives but the
+objects it points at do not, the parser returns the pages it could read — a success
+over an incomplete page set. Check before indexing or archiving, because a page that
+silently never arrived is indistinguishable from a page that never existed:
+
+```python
+quality = unpdf.get_extraction_quality("document.pdf")
+if quality["pages_incomplete"]:
+    print(f"incomplete - document declares {quality['declared_page_count']} page(s)")
+```
+
+| Field | Meaning |
+|-------|---------|
+| `pages_incomplete` | Pages are known to be missing. The one field to branch on. |
+| `declared_page_count` | Page count the document declares, or `None` if unreadable. |
+| `unresolved_page_nodes` | Unreadable page-tree *nodes* — non-zero means incomplete, **not** a page count. |
+| `skipped_object_count` | Objects that could not be loaded. Most cost no page. |
+
+Also note that `get_info()["resource_count"]` counts the extracted-resource
+inventory, which this binding's parse path leaves empty (resource extraction is off
+by default to bound peak memory) — it is not a count of images on the page. Use
+`get_page_stats` for scan detection.
+
+## Handling failures
+
+`UnpdfError` carries a `kind` so you can branch on the reason a call failed instead
+of matching on message text:
+
+```python
+from unpdf import to_text, ErrorKind, UnpdfError
+
+try:
+    text = to_text("document.pdf")
+except UnpdfError as e:
+    if e.kind == ErrorKind.ENCRYPTED:
+        print("Password required")
+    elif e.kind in (ErrorKind.CORRUPTED, ErrorKind.PDF_PARSE):
+        print("The file is damaged")
+    else:
+        print(f"Extraction failed ({e.kind.name}): {e}")
+```
+
+`UnpdfError` subclasses `RuntimeError`, so existing `except RuntimeError` handlers
+keep working. `ErrorKind` values are part of the native ABI: new reasons take new
+numbers and existing ones are never renumbered, so treat an unrecognised value as a
+generic failure.
+
+## License
+
+MIT License

unpdf_markdown-0.13.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "unpdf-markdown"
+version = "0.13.0"
+description = "Python bindings for unpdf - High-performance PDF content extraction"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "iyulab"}
+]
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = ["pdf", "markdown", "text-extraction", "document", "parser"]
+
+[project.urls]
+Homepage = "https://github.com/iyulab/unpdf"
+Documentation = "https://github.com/iyulab/unpdf"
+Repository = "https://github.com/iyulab/unpdf"
+Issues = "https://github.com/iyulab/unpdf/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+unpdf = ["lib/**/*"]

unpdf_markdown-0.13.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

unpdf_markdown-0.13.0/src/unpdf/__init__.py

@@ -0,0 +1,41 @@
+"""
+unpdf - Python bindings for unpdf PDF extraction library.
+"""
+
+from .unpdf import (
+    UNPDF_FLAG_ESCAPE_SPECIAL,
+    UNPDF_FLAG_FRONTMATTER,
+    UNPDF_FLAG_PAGE_MARKERS,
+    UNPDF_FLAG_REFINE,
+    ErrorKind,
+    PdfSource,
+    UnpdfError,
+    to_markdown,
+    to_text,
+    to_json,
+    get_info,
+    get_extraction_quality,
+    get_page_stats,
+    get_page_count,
+    is_pdf,
+    version,
+)
+
+__all__ = [
+    "UNPDF_FLAG_ESCAPE_SPECIAL",
+    "UNPDF_FLAG_FRONTMATTER",
+    "UNPDF_FLAG_PAGE_MARKERS",
+    "UNPDF_FLAG_REFINE",
+    "ErrorKind",
+    "PdfSource",
+    "UnpdfError",
+    "to_markdown",
+    "to_text",
+    "to_json",
+    "get_info",
+    "get_extraction_quality",
+    "get_page_stats",
+    "get_page_count",
+    "is_pdf",
+    "version",
+]

unpdf_markdown-0.13.0/src/unpdf/_native.py

@@ -0,0 +1,201 @@
+"""Native library loading for unpdf."""
+
+import ctypes
+import platform
+import os
+import subprocess
+from pathlib import Path
+
+# Library filename by platform
+_LIB_NAMES = {
+    "Windows": "unpdf.dll",
+    "Linux": "libunpdf.so",
+    "Darwin": "libunpdf.dylib",
+}
+
+
+def _is_musl() -> bool:
+    """Detect if the current Linux system uses musl libc."""
+    # Check if /etc/os-release indicates Alpine
+    try:
+        osrelease = Path("/etc/os-release").read_text()
+        if "alpine" in osrelease.lower():
+            return True
+    except OSError:
+        pass
+    # Check ldd version output (musl ldd identifies itself)
+    try:
+        result = subprocess.run(
+            ["ldd", "--version"], capture_output=True, text=True, timeout=5
+        )
+        output = result.stdout + result.stderr
+        if "musl" in output.lower():
+            return True
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    return False
+
+
+def _get_linux_runtime_id(machine: str) -> str:
+    """Get the runtime ID for Linux, detecting musl vs glibc."""
+    if machine == "x86_64":
+        return "linux-musl-x64" if _is_musl() else "linux-x64"
+    raise OSError(f"Unsupported Linux architecture: {machine}")
+
+
+# Runtime identifier
+_RUNTIME_IDS = {
+    ("Windows", "AMD64"): "win-x64",
+    ("Windows", "x86_64"): "win-x64",
+    ("Darwin", "x86_64"): "osx-x64",
+    ("Darwin", "arm64"): "osx-arm64",
+}
+
+
+def _get_lib_path() -> Path:
+    """Get the path to the native library."""
+    system = platform.system()
+    machine = platform.machine()
+
+    lib_name = _LIB_NAMES.get(system)
+    if not lib_name:
+        raise OSError(f"Unsupported platform: {system}")
+
+    # Check UNPDF_LIB_PATH environment variable first
+    env_path = os.environ.get("UNPDF_LIB_PATH")
+    if env_path:
+        p = Path(env_path)
+        if p.exists():
+            return p
+
+    if system == "Linux":
+        runtime_id = _get_linux_runtime_id(machine)
+    else:
+        runtime_id = _RUNTIME_IDS.get((system, machine))
+        if not runtime_id:
+            raise OSError(f"Unsupported architecture: {system}/{machine}")
+
+    # Look for the library in the package
+    package_dir = Path(__file__).parent
+    lib_path = package_dir / "lib" / runtime_id / lib_name
+
+    if lib_path.exists():
+        return lib_path
+
+    # Fallback: look in package root
+    lib_path = package_dir / "lib" / lib_name
+    if lib_path.exists():
+        return lib_path
+
+    # Fallback: look in current directory
+    lib_path = Path(lib_name)
+    if lib_path.exists():
+        return lib_path
+
+    # Fallback: system library path
+    return Path(lib_name)
+
+
+def _load_library() -> ctypes.CDLL:
+    """Load the native unpdf library."""
+    lib_path = _get_lib_path()
+
+    try:
+        if platform.system() == "Windows":
+            # On Windows, use LoadLibraryEx with LOAD_WITH_ALTERED_SEARCH_PATH
+            return ctypes.CDLL(str(lib_path), winmode=0)
+        else:
+            return ctypes.CDLL(str(lib_path))
+    except OSError as e:
+        raise OSError(
+            f"Failed to load unpdf native library from {lib_path}: {e}\n"
+            f"Make sure the library is installed for your platform ({platform.system()}/{platform.machine()})."
+        ) from e
+
+
+# Load the library eagerly
+_lib = _load_library()
+
+# Define function signatures
+_lib.unpdf_version.argtypes = []
+_lib.unpdf_version.restype = ctypes.c_char_p
+
+_lib.unpdf_last_error.argtypes = []
+_lib.unpdf_last_error.restype = ctypes.c_char_p
+
+_lib.unpdf_last_error_kind.argtypes = []
+_lib.unpdf_last_error_kind.restype = ctypes.c_int
+
+_lib.unpdf_parse_file.argtypes = [ctypes.c_char_p]
+_lib.unpdf_parse_file.restype = ctypes.c_void_p
+
+_lib.unpdf_parse_bytes.argtypes = [ctypes.POINTER(ctypes.c_uint8), ctypes.c_size_t]
+_lib.unpdf_parse_bytes.restype = ctypes.c_void_p
+
+_lib.unpdf_free_document.argtypes = [ctypes.c_void_p]
+_lib.unpdf_free_document.restype = None
+
+_lib.unpdf_to_markdown.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_lib.unpdf_to_markdown.restype = ctypes.c_char_p
+
+_lib.unpdf_to_text.argtypes = [ctypes.c_void_p]
+_lib.unpdf_to_text.restype = ctypes.c_char_p
+
+_lib.unpdf_to_json.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_lib.unpdf_to_json.restype = ctypes.c_char_p
+
+_lib.unpdf_plain_text.argtypes = [ctypes.c_void_p]
+_lib.unpdf_plain_text.restype = ctypes.c_char_p
+
+_lib.unpdf_section_count.argtypes = [ctypes.c_void_p]
+_lib.unpdf_section_count.restype = ctypes.c_int
+
+_lib.unpdf_resource_count.argtypes = [ctypes.c_void_p]
+_lib.unpdf_resource_count.restype = ctypes.c_int
+
+_lib.unpdf_get_title.argtypes = [ctypes.c_void_p]
+_lib.unpdf_get_title.restype = ctypes.c_char_p
+
+_lib.unpdf_get_author.argtypes = [ctypes.c_void_p]
+_lib.unpdf_get_author.restype = ctypes.c_char_p
+
+_lib.unpdf_free_string.argtypes = [ctypes.c_char_p]
+_lib.unpdf_free_string.restype = None
+
+_lib.unpdf_get_extraction_quality.argtypes = [ctypes.c_void_p]
+_lib.unpdf_get_extraction_quality.restype = ctypes.c_char_p
+
+_lib.unpdf_page_stats.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_lib.unpdf_page_stats.restype = ctypes.c_char_p
+
+_lib.unpdf_get_resource_ids.argtypes = [ctypes.c_void_p]
+_lib.unpdf_get_resource_ids.restype = ctypes.c_char_p
+
+_lib.unpdf_get_resource_info.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+_lib.unpdf_get_resource_info.restype = ctypes.c_char_p
+
+_lib.unpdf_get_resource_data.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_char_p,
+    ctypes.POINTER(ctypes.c_size_t),
+]
+_lib.unpdf_get_resource_data.restype = ctypes.POINTER(ctypes.c_uint8)
+
+_lib.unpdf_free_bytes.argtypes = [ctypes.POINTER(ctypes.c_uint8), ctypes.c_size_t]
+_lib.unpdf_free_bytes.restype = None
+
+# Export constants
+UNPDF_FLAG_FRONTMATTER = 1
+UNPDF_FLAG_ESCAPE_SPECIAL = 2
+# Bit 4 is retired: it named a paragraph-spacing option that never reached the
+# renderer. Retired bits are not reused.
+UNPDF_FLAG_PAGE_MARKERS = 8
+UNPDF_FLAG_REFINE = 16
+
+UNPDF_JSON_PRETTY = 0
+UNPDF_JSON_COMPACT = 1
+
+
+def get_library():
+    """Get the loaded native library."""
+    return _lib