docling-parse 7.6.0__tar.gz → 7.7.1__tar.gz

{docling_parse-7.6.0 → docling_parse-7.7.1}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [v7.7.1](https://github.com/docling-project/docling-parse/releases/tag/v7.7.1) - 2026-07-10
+
+### Fix
+
+* Fixing the word extraction with spaces as blockers ([#296](https://github.com/docling-project/docling-parse/issues/296)) ([`66e4c33`](https://github.com/docling-project/docling-parse/commit/66e4c339578679fb13410d91261ad5160af5220a))
+* Arabic pdf-rendering ([#295](https://github.com/docling-project/docling-parse/issues/295)) ([`ff00fcf`](https://github.com/docling-project/docling-parse/commit/ff00fcfe7e59a5a81c24fb01332a023c75cc8f0f))
+
+## [v7.7.0](https://github.com/docling-project/docling-parse/releases/tag/v7.7.0) - 2026-07-08
+
+### Feature
+
+* Build wheel for windows arm64 ([#288](https://github.com/docling-project/docling-parse/issues/288)) ([`9acdc48`](https://github.com/docling-project/docling-parse/commit/9acdc4838e7976c329d5dda150eef1c656011e04))
+
 ## [v7.6.0](https://github.com/docling-project/docling-parse/releases/tag/v7.6.0) - 2026-07-06
 
 ### Feature

{docling_parse-7.6.0 → docling_parse-7.7.1}/CMakeLists.txt

@@ -75,7 +75,33 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if (WIN32)
     set(TEST_PATH "\\\"${TOPLEVEL_PREFIX_PATH}\\\"")
     add_definitions(-DROOT_PATH="\\\"${TOPLEVEL_PREFIX_PATH}\\\"")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-sign-compare -O3 ${ENV_ARCHFLAGS}")
+    if(MSVC)
+        # cl rejects GCC/Clang-style flags: -Wall / -Wno-sign-compare / -O3 are
+        # parsed as invalid /W... and /O... arguments (error D8021), and these
+        # flags are inherited by the in-tree subprojects (loguru, blend2d,
+        # pdfium_jbig2). Optimization comes from a Release build instead: MSVC
+        # Release uses /O2 (the -O3 equivalent) and links the redistributable
+        # release CRT (/MD). Restrict the multi-config Visual Studio generator to
+        # Release so a config-less `cmake --build` cannot fall back to a Debug
+        # build depending on the non-redistributable debug CRT. The build is
+        # invoked with --config Release (see local_build.py).
+        set(CMAKE_CONFIGURATION_TYPES "Release" CACHE STRING "MSVC build configurations" FORCE)
+
+        # Source files are UTF-8. Without /utf-8, MSVC reads multi-byte characters
+        # (e.g. the curly quotes and en/em dashes in src/parse/utils/string.h) as
+        # multi-character constants -> error C2015. GCC/Clang assume UTF-8, so this
+        # only bites the MSVC/arm64 build.
+        add_compile_options(/utf-8)
+        # MSVC's <cmath> only exposes M_PI (used in src/parse/utils/values.h) when
+        # _USE_MATH_DEFINES is defined before the include -> without it, C2065.
+        # NOMINMAX stops <windows.h> from defining min()/max() function-like
+        # macros, which otherwise collide with std::numeric_limits<T>::max() in
+        # qpdf's QIntC.hh (and std::min/std::max in general) -> error C2589.
+        add_compile_definitions(_USE_MATH_DEFINES NOMINMAX)
+    else()
+        # MinGW/GCC toolchain (Windows amd64)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-sign-compare -O3 ${ENV_ARCHFLAGS}")
+    endif()
 else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-sign-compare -O3 -DROOT_PATH='\"${TOPLEVEL_PREFIX_PATH}\"' ${ENV_ARCHFLAGS}")
   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-sign-compare -g3 -O0 -fno-omit-frame-pointer -DROOT_PATH='\"${TOPLEVEL_PREFIX_PATH}\"' ${ENV_ARCHFLAGS}")

{docling_parse-7.6.0 → docling_parse-7.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.6.0
+Version: 7.7.1
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT
@@ -47,6 +47,7 @@ uv run python ./docling_parse/visualize.py -i <path-to-pdf-file> -c word --inter
 ```
 
 <table>
+
   <tr>
     <th>original</th>
     <th>char</th>

{docling_parse-7.6.0 → docling_parse-7.7.1}/README.md

@@ -16,6 +16,7 @@ uv run python ./docling_parse/visualize.py -i <path-to-pdf-file> -c word --inter
 ```
 
 <table>
+
   <tr>
     <th>original</th>
     <th>char</th>

{docling_parse-7.6.0 → docling_parse-7.7.1}/cmake/extlib_freetype.cmake

@@ -20,7 +20,14 @@ else()
 
     set(FREETYPE_URL https://github.com/freetype/freetype.git)
     set(FREETYPE_TAG VER-2-13-3)
-    set(FREETYPE_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libfreetype.a)
+    # GCC/MinGW -> libfreetype.a, MSVC -> freetype.lib (Windows arm64 uses MSVC).
+    # DISABLE_FORCE_DEBUG_POSTFIX + Release avoid the "d" postfix, so the name is
+    # stable per-toolchain.
+    if(MSVC)
+        set(FREETYPE_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/freetype.lib)
+    else()
+        set(FREETYPE_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libfreetype.a)
+    endif()
 
     # All optional codec/shaping dependencies are disabled: the renderer only
     # needs outline loading for Type 1 / CFF / TrueType font programs, and a

{docling_parse-7.6.0 → docling_parse-7.7.1}/cmake/extlib_jpeg.cmake

@@ -19,6 +19,18 @@ else()
     set(JPEG_URL https://github.com/libjpeg-turbo/libjpeg-turbo.git)
     # set(JPEG_TAG 3.0.3)
     set(JPEG_TAG 3.1.1)
+
+    # -A ARM64 (CMAKE_GENERATOR_PLATFORM) only sets the MSBuild target platform.
+    # CMAKE_SYSTEM_PROCESSOR is a separate variable that CMake always resets to
+    # the host-reported architecture unless CMAKE_SYSTEM_NAME is also given (see
+    # CMakeDetermineSystem.cmake); on this CI runner the host reports AMD64. Without
+    # forcing both, libjpeg-turbo's own CMakeLists picks its x86_64 NASM SIMD
+    # backend and fails to link against the ARM64 target.
+    set(JPEG_EXTRA_CMAKE_ARGS "")
+    if(WIN32 AND CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64")
+        set(JPEG_EXTRA_CMAKE_ARGS -DCMAKE_SYSTEM_NAME=Windows -DCMAKE_SYSTEM_PROCESSOR=ARM64)
+    endif()
+
     ExternalProject_Add(extlib_jpeg
 
         PREFIX extlib_jpeg
@@ -37,17 +49,27 @@ else()
         -DCMAKE_C_FLAGS=${ENV_ARCHFLAGS} \\
         -DARMV8_BUILD=ON \\
         -DCMAKE_INSTALL_LIBDIR=${EXTERNALS_PREFIX_PATH}/lib \\
-        -DCMAKE_INSTALL_PREFIX=${EXTERNALS_PREFIX_PATH}
+        -DCMAKE_INSTALL_PREFIX=${EXTERNALS_PREFIX_PATH} \\
+        ${JPEG_EXTRA_CMAKE_ARGS}
 
         BUILD_IN_SOURCE ON
         LOG_DOWNLOAD ON
         # LOG_BUILD ON
     )
 
+    # GCC/MinGW and MSVC name the installed static library differently:
+    # GCC/MinGW -> libjpeg.a, MSVC -> jpeg-static.lib. The Windows arm64 wheel
+    # builds with MSVC (Visual Studio generator), so pick the name per-toolchain.
+    if(MSVC)
+        set(JPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/jpeg-static.lib)
+    else()
+        set(JPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a)
+    endif()
+
     add_library(${ext_name} STATIC IMPORTED)
     add_dependencies(${ext_name} extlib_jpeg)
     set_target_properties(${ext_name} PROPERTIES
-        IMPORTED_LOCATION ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a
+        IMPORTED_LOCATION ${JPEG_IMPORTED_LIB}
         INTERFACE_INCLUDE_DIRECTORIES ${EXTERNALS_PREFIX_PATH}/include
     )
 

docling_parse-7.7.1/cmake/extlib_lcms2.cmake

@@ -0,0 +1,102 @@
+message(STATUS "entering in extlib_lcms2.cmake")
+
+set(ext_name "lcms2")
+
+if(USE_SYSTEM_DEPS)
+    find_package(PkgConfig)
+    if(PkgConfig_FOUND)
+        pkg_check_modules(liblcms2 IMPORTED_TARGET lcms2)
+    endif()
+
+    if(TARGET PkgConfig::liblcms2)
+        add_library(${ext_name} ALIAS PkgConfig::liblcms2)
+    else()
+        find_path(LCMS2_INCLUDE_DIR lcms2.h)
+        find_library(LCMS2_LIBRARY NAMES lcms2 liblcms2)
+
+        if(NOT LCMS2_INCLUDE_DIR OR NOT LCMS2_LIBRARY)
+            message(FATAL_ERROR "lcms2 not found. Install Little CMS 2 or disable USE_SYSTEM_DEPS.")
+        endif()
+
+        add_library(${ext_name} UNKNOWN IMPORTED)
+        set_target_properties(${ext_name} PROPERTIES
+            IMPORTED_LOCATION "${LCMS2_LIBRARY}"
+            INTERFACE_INCLUDE_DIRECTORIES "${LCMS2_INCLUDE_DIR}"
+        )
+    endif()
+
+else()
+    include(ExternalProject)
+    include(CMakeParseArguments)
+
+    file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/include)
+    file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/lib)
+
+    set(LCMS2_URL https://github.com/mm2/Little-CMS.git)
+    set(LCMS2_TAG lcms2.17)
+
+    if(MSVC)
+        # Upstream lcms2 has no CMakeLists and its ./configure cannot run under
+        # MSVC (no Unix shell on the Windows arm64 runner). Inject a vendored
+        # CMakeLists.txt and build with the active MSVC generator. Produces
+        # lcms2.lib.
+        set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/lcms2.lib)
+
+        ExternalProject_Add(extlib_lcms2
+            PREFIX extlib_lcms2
+
+            UPDATE_COMMAND ""
+            GIT_REPOSITORY ${LCMS2_URL}
+            GIT_TAG ${LCMS2_TAG}
+
+            BUILD_ALWAYS OFF
+
+            INSTALL_DIR ${EXTERNALS_PREFIX_PATH}
+
+            PATCH_COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_LIST_DIR}/lcms2_CMakeLists.txt
+                <SOURCE_DIR>/CMakeLists.txt
+
+            CMAKE_ARGS \\
+            -DCMAKE_POSITION_INDEPENDENT_CODE=ON \\
+            -DCMAKE_BUILD_TYPE=Release \\
+            -DCMAKE_INSTALL_PREFIX=${EXTERNALS_PREFIX_PATH}
+
+            LOG_DOWNLOAD ON
+        )
+    else()
+        # Unix (macOS/Linux) and MinGW on Windows amd64 build via autotools.
+        # Produces liblcms2.a.
+        set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/liblcms2.a)
+
+        ExternalProject_Add(extlib_lcms2
+            PREFIX extlib_lcms2
+
+            UPDATE_COMMAND ""
+            GIT_REPOSITORY ${LCMS2_URL}
+            GIT_TAG ${LCMS2_TAG}
+
+            BUILD_ALWAYS OFF
+
+            INSTALL_DIR ${EXTERNALS_PREFIX_PATH}
+
+            BUILD_IN_SOURCE ON
+            CONFIGURE_COMMAND ./configure
+                --prefix=${EXTERNALS_PREFIX_PATH}
+                --disable-shared
+                --enable-static
+                CFLAGS=-fPIC\ ${ENV_ARCHFLAGS}
+            BUILD_COMMAND make
+            INSTALL_COMMAND make install
+
+            LOG_DOWNLOAD ON
+        )
+    endif()
+
+    add_library(${ext_name} STATIC IMPORTED)
+    add_dependencies(${ext_name} extlib_lcms2)
+    set_target_properties(${ext_name} PROPERTIES
+        IMPORTED_LOCATION ${LCMS2_IMPORTED_LIB}
+        INTERFACE_INCLUDE_DIRECTORIES ${EXTERNALS_PREFIX_PATH}/include
+    )
+endif()

{docling_parse-7.6.0 → docling_parse-7.7.1}/cmake/extlib_openjpeg.cmake

@@ -19,7 +19,12 @@ else()
 
     set(OPENJPEG_URL https://github.com/uclouvain/openjpeg.git)
     set(OPENJPEG_TAG v2.5.3)
-    set(OPENJPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libopenjp2.a)
+    # GCC/MinGW -> libopenjp2.a, MSVC -> openjp2.lib (Windows arm64 uses MSVC).
+    if(MSVC)
+        set(OPENJPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/openjp2.lib)
+    else()
+        set(OPENJPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libopenjp2.a)
+    endif()
 
     ExternalProject_Add(extlib_openjpeg
 

{docling_parse-7.6.0 → docling_parse-7.7.1}/cmake/extlib_qpdf_v11.cmake

@@ -19,9 +19,17 @@ else()
 
   set(QPDF_URL https://github.com/qpdf/qpdf.git)
   #set(QPDF_TAG v11.9.1 )	
-  set(QPDF_TAG v11.10.0 )	  
-  set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/libqpdf.a)
-  set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a)
+  set(QPDF_TAG v11.10.0 )
+  # GCC/MinGW and MSVC name the installed static libraries differently
+  # (GCC/MinGW -> libqpdf.a / libjpeg.a, MSVC -> qpdf.lib / jpeg-static.lib).
+  # The Windows arm64 wheel builds with MSVC, so select the names per-toolchain.
+  if(MSVC)
+      set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/qpdf.lib)
+      set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/jpeg-static.lib)
+  else()
+      set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/libqpdf.a)
+      set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a)
+  endif()
 
   if(UNIX)
       set(QPDF_EXTRA_CXX_FLAGS "-fPIC ")

{docling_parse-7.6.0 → docling_parse-7.7.1}/cmake/extlib_qpdf_v12.cmake

@@ -20,8 +20,16 @@ else()
   set(QPDF_URL https://github.com/qpdf/qpdf.git)
   
   set(QPDF_TAG v12.2.0 )
-  set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/libqpdf.a)
-  set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a)
+  # GCC/MinGW and MSVC name the installed static libraries differently
+  # (GCC/MinGW -> libqpdf.a / libjpeg.a, MSVC -> qpdf.lib / jpeg-static.lib).
+  # The Windows arm64 wheel builds with MSVC, so select the names per-toolchain.
+  if(MSVC)
+      set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/qpdf.lib)
+      set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/jpeg-static.lib)
+  else()
+      set(QPDF_LIB ${EXTERNALS_PREFIX_PATH}/lib/libqpdf.a)
+      set(JPEG_LIB ${EXTERNALS_PREFIX_PATH}/lib/libjpeg.a)
+  endif()
 
   if(UNIX)
       set(QPDF_EXTRA_CXX_FLAGS "-fPIC ")

docling_parse-7.7.1/cmake/lcms2_CMakeLists.txt

@@ -0,0 +1,24 @@
+# Minimal CMake build for Little-CMS (lcms2).
+#
+# Upstream ships no CMakeLists.txt (only autotools + meson + hand-written Visual
+# Studio projects), and its ./configure cannot run under MSVC on the Windows
+# ARM64 runner (no Unix shell). extlib_lcms2.cmake injects this file as the
+# source-tree CMakeLists.txt via the ExternalProject PATCH_COMMAND so lcms2 can
+# be built with the active MSVC generator, like the other from-source externals.
+cmake_minimum_required(VERSION 3.15)
+project(lcms2 C)
+
+# The library is exactly src/*.c; utilities/tests live outside src/.
+file(GLOB LCMS2_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.c")
+
+add_library(lcms2 STATIC ${LCMS2_SOURCES})
+target_include_directories(lcms2 PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+# Leave CMS_DLL / CMS_DLL_BUILD undefined so CMSAPI resolves to plain symbols
+# (no __declspec(dllimport/dllexport)) for static build and static consumption.
+
+install(TARGETS lcms2 ARCHIVE DESTINATION lib)
+install(FILES
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/lcms2.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/lcms2_plugin.h"
+    DESTINATION include)

{docling_parse-7.6.0 → docling_parse-7.7.1}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.6.0
+Version: 7.7.1
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT
@@ -47,6 +47,7 @@ uv run python ./docling_parse/visualize.py -i <path-to-pdf-file> -c word --inter
 ```
 
 <table>
+
   <tr>
     <th>original</th>
     <th>char</th>

{docling_parse-7.6.0 → docling_parse-7.7.1}/docling_parse.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ cmake/extlib_qpdf_v10.cmake
 cmake/extlib_qpdf_v11.cmake
 cmake/extlib_qpdf_v12.cmake
 cmake/extlib_utf8.git.cmake
+cmake/lcms2_CMakeLists.txt
 cmake/os_opts.cmake
 cmake/subdirlist.cmake
 docling_parse/__init__.py
@@ -661,10 +662,12 @@ src/third_party/pdfium_jbig2/core/fxcrt/numerics/safe_math_shared_impl.h
 tests/README.md
 tests/__init__.py
 tests/conftest.py
+tests/constants.py
 tests/data_utils.py
 tests/rendering_regression.py
 tests/test_embedded_fonts.py
 tests/test_locale_safety.py
 tests/test_parse.py
 tests/test_threaded_parse.py
-tests/test_threaded_render.py
+tests/test_threaded_render.py
+tests/update_groundtruth.py

docling_parse-7.7.1/local_build.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+import os
+
+import sys
+
+import subprocess
+from typing import List
+import pybind11
+
+ROOT_DIR = os.path.abspath("./")
+BUILD_DIR = os.path.join(ROOT_DIR, "build")
+
+def get_pybind11_cmake_args():
+        pybind11_sys_path = os.getenv("PYBIND11_SYSPATH")
+        if pybind11_sys_path:
+            # pybind11_include_dir = os.path.join(pybind11_sys_path, "include")
+            pybind11_cmake_dir = os.path.join(pybind11_sys_path, "share", "cmake", "pybind11")
+        else:
+            # pybind11_include_dir = pybind11.get_include()
+            pybind11_cmake_dir = pybind11.get_cmake_dir()
+        # print(f"{pybind11_include_dir=}")
+        print(f"{pybind11_cmake_dir=}")
+        return [f"-Dpybind11_DIR={pybind11_cmake_dir}"]
+
+
+def get_cross_python_cmake_args():
+    """Forward the target-Python headers/libs to CMake when cibuildwheel
+    cross-compiles (e.g. win_arm64 built on an amd64 host for CPython < 3.12,
+    which has no native arm64 runner Python).
+
+    In that mode cibuildwheel runs a host (amd64) interpreter and passes the
+    arm64 target's include/library dirs to distutils build_ext through the file
+    named by DIST_EXTRA_CONFIG. This build drives CMake directly and never runs
+    distutils build_ext, so pybind11 would otherwise resolve the host amd64
+    pythonXY.lib and the arm64 extension fails to link (unresolved __imp_Py*
+    symbols). Re-export those dirs to CMake's modern FindPython instead.
+    """
+    dist_extra = os.getenv("DIST_EXTRA_CONFIG")
+    if not dist_extra or not os.path.isfile(dist_extra):
+        return []
+
+    import configparser
+    import glob
+
+    # RawConfigParser: paths contain characters (e.g. '%') that the default
+    # interpolation would choke on.
+    cfg = configparser.RawConfigParser()
+    cfg.read(dist_extra)
+    if not cfg.has_section("build_ext"):
+        return []
+
+    include_dir = cfg.get("build_ext", "include_dirs", fallback="").strip().splitlines()
+    library_dir = cfg.get("build_ext", "library_dirs", fallback="").strip().splitlines()
+
+    args = []
+    # Switch pybind11 to CMake's modern FindPython, which honors the explicit
+    # Python_INCLUDE_DIR / Python_LIBRARY hints below (the legacy
+    # FindPythonLibsNew derives them from the host interpreter's arch).
+    args.append("-DPYBIND11_FINDPYTHON=ON")
+    # FindPython uses the mixed-case name; pin it to the build interpreter so it
+    # does not pick a different Python off PATH.
+    args.append(f"-DPython_EXECUTABLE={sys.executable}")
+    if include_dir:
+        args.append(f"-DPython_INCLUDE_DIR={include_dir[0].strip()}")
+    if library_dir:
+        libs = glob.glob(os.path.join(library_dir[0].strip(), "python*.lib"))
+        # Prefer the versioned python3XY.lib over the stable-ABI python3.lib.
+        versioned = [l for l in libs if not l.lower().endswith("python3.lib")]
+        chosen = (versioned or libs)
+        if chosen:
+            args.append(f"-DPython_LIBRARY={chosen[0]}")
+
+    print(f"cross-compile python cmake args: {args}")
+    return args
+
+def run(cmd: List[str], cwd: str="./"):
+
+    print_cmd = " ".join(cmd)
+    print(f"\nlaunch: {print_cmd}")
+
+    message = subprocess.run(cmd, cwd=cwd)
+
+    if "returncode=0" in str(message):
+        print(f" -> SUCCESS")
+        return True
+
+    print(f" -> ERROR with message: '{message}'\n")
+    return False
+
+
+def build_local(num_threads: int):
+
+    USE_SYSTEM_DEPS = os.getenv("USE_SYSTEM_DEPS", "OFF")
+
+    print("python prefix: ", sys.exec_prefix)
+    print("python executable: ", sys.executable)
+    config_cmd = [
+        "cmake",
+        "-B", f"{BUILD_DIR}",
+        f"-DUSE_SYSTEM_DEPS={USE_SYSTEM_DEPS}",
+        f"-DPYTHON_EXECUTABLE={sys.executable}",
+    ]
+
+    # Forward CMAKE_GENERATOR so callers (e.g. the CI workflow) can switch the
+    # generator without patching this script (e.g. "Visual Studio 17 2022" for
+    # MSVC on Windows ARM64 vs "MSYS Makefiles" for MinGW on Windows AMD64).
+    cmake_generator = os.getenv("CMAKE_GENERATOR")
+    if cmake_generator:
+        config_cmd.extend(["-G", cmake_generator])
+
+    # Forward extra cmake flags supplied via CMAKE_ARGS (e.g. "-A ARM64
+    # -DZLIB_ROOT=...").  Split on whitespace but respect quoted strings.
+    cmake_args_env = os.getenv("CMAKE_ARGS", "").strip()
+    if cmake_args_env:
+        import shlex
+        config_cmd.extend(shlex.split(cmake_args_env))
+
+    config_cmd.extend(get_pybind11_cmake_args())
+    config_cmd.extend(get_cross_python_cmake_args())
+    success = run(config_cmd, cwd=ROOT_DIR)
+    if not success:
+        raise RuntimeError("Error building.")
+
+    build_cmd = [
+        "cmake",
+        "--build", f"{BUILD_DIR}",
+        "--target=install",
+        # Authoritative for multi-config generators (e.g. Visual Studio on Windows
+        # ARM64): builds Release so MSVC uses /O2 and the redistributable release
+        # CRT. Ignored by single-config generators (Makefiles/Ninja on Linux,
+        # macOS and MinGW), where the optimization level comes from CMAKE_CXX_FLAGS.
+        "--config", "Release",
+    ]
+    if num_threads > 1:
+        build_cmd.extend(["-j", f"{num_threads}"])
+    success = run(build_cmd, cwd=ROOT_DIR)
+    if not success:
+        raise RuntimeError("Error building.")
+
+
+if "__main__" == __name__:
+    num_threads = int(os.getenv("BUILD_THREADS", "4"))
+    print(f"Building with {num_threads} threads (BUILD_THREADS={os.getenv('BUILD_THREADS', 'not set, defaulting to 4')})")
+    build_local(num_threads=num_threads)

{docling_parse-7.6.0 → docling_parse-7.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.6.0"
+version = "7.7.1"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]