mlc-doxygen-bin 1.17.0__tar.gz

mlc_doxygen_bin-1.17.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include setup.py
+recursive-include scripts *.py *.sh *.ps1
+recursive-include src/mlc_doxygen_bin *.py py.typed
+prune src/mlc_doxygen_bin/bin
+prune src/mlc_doxygen_bin/licenses
+exclude src/mlc_doxygen_bin/*.json

mlc_doxygen_bin-1.17.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: mlc-doxygen-bin
+Version: 1.17.0
+Summary: Prebuilt Doxygen 1.17.0 command-line executable
+Author-email: MLC AI <mlc.ai.dev@gmail.com>
+License-Expression: GPL-2.0-only
+Project-URL: Doxygen, https://github.com/doxygen/doxygen
+Project-URL: Repository, https://github.com/mlc-ai/package
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# mlc-doxygen-bin
+
+`mlc-doxygen-bin` builds platform wheels containing the Doxygen 1.17.0 command-line
+executable. It is intended for Python-driven build systems that want a pinned
+Doxygen binary without relying on a system package manager.
+
+The wheel installs a `doxygen` console script that delegates to the executable
+stored inside the Python package.
+
+## Build Wheels
+
+For Doxygen 1.17.0 on macOS:
+
+```bash
+scripts/wheel_macos_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on manylinux_2_28:
+
+```bash
+scripts/wheel_manylinux_2_28_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on Windows:
+
+```powershell
+scripts\wheel_windows_v1_17_0.ps1
+```
+
+The scripts run `cibuildwheel==3.3.1` through `uv`. During CIBW's
+`before-build` phase, `scripts/prepare_doxygen_v1_17_0.py` downloads the pinned
+upstream source archive, verifies its SHA-256 digest, builds the CLI executable,
+and copies the install tree into `src/mlc_doxygen_bin`.
+
+Build artifacts are written to `wheelhouse/`.
+
+## Platform And Architecture
+
+The Linux and macOS scripts default to the host architecture. Override the
+target architecture with:
+
+```bash
+MLC_DOXYGEN_BIN_ARCH=aarch64 scripts/wheel_manylinux_2_28_v1_17_0.sh
+MLC_DOXYGEN_BIN_ARCH=arm64 scripts/wheel_macos_v1_17_0.sh
+```
+
+Supported values are:
+
+- Linux: `x86_64`, `aarch64`
+- macOS: `arm64`, `x86_64`
+- Windows: `AMD64`
+
+## Build Dependencies
+
+The build needs CMake, Ninja, Python, Flex, Bison, and a C++ compiler. The
+manylinux script installs Bison from the manylinux distribution and builds a
+pinned Flex 2.6.4 into `/usr/local`, because AlmaLinux 8's Flex 2.6.1 can fail
+while generating Doxygen's large scanners.
+
+On macOS, use Homebrew Flex and Bison if the Apple-provided versions are too
+old:
+
+```bash
+brew install flex bison
+```
+
+The macOS script automatically prepends Homebrew's `flex` and `bison`
+directories to `PATH` when Homebrew is available.
+
+On Windows, install Visual Studio Build Tools and `winflexbison3`.
+
+## Runtime Scope
+
+This package intentionally builds only the Doxygen CLI executable. It does not
+bundle `doxywizard`, `doxyindexer`, `doxysearch.cgi`, libclang, Graphviz,
+LaTeX, Ghostscript, or PlantUML. Those tools remain external runtime
+dependencies for Doxygen features that need them.
+
+## Usage
+
+```bash
+python -m pip install mlc-doxygen-bin==1.17.0
+doxygen --version
+```
+
+Programmatic path lookup is also available:
+
+```python
+import mlc_doxygen_bin
+
+print(mlc_doxygen_bin.get_executable_path())
+print(mlc_doxygen_bin.metadata())
+```

mlc_doxygen_bin-1.17.0/README.md

@@ -0,0 +1,93 @@
+# mlc-doxygen-bin
+
+`mlc-doxygen-bin` builds platform wheels containing the Doxygen 1.17.0 command-line
+executable. It is intended for Python-driven build systems that want a pinned
+Doxygen binary without relying on a system package manager.
+
+The wheel installs a `doxygen` console script that delegates to the executable
+stored inside the Python package.
+
+## Build Wheels
+
+For Doxygen 1.17.0 on macOS:
+
+```bash
+scripts/wheel_macos_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on manylinux_2_28:
+
+```bash
+scripts/wheel_manylinux_2_28_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on Windows:
+
+```powershell
+scripts\wheel_windows_v1_17_0.ps1
+```
+
+The scripts run `cibuildwheel==3.3.1` through `uv`. During CIBW's
+`before-build` phase, `scripts/prepare_doxygen_v1_17_0.py` downloads the pinned
+upstream source archive, verifies its SHA-256 digest, builds the CLI executable,
+and copies the install tree into `src/mlc_doxygen_bin`.
+
+Build artifacts are written to `wheelhouse/`.
+
+## Platform And Architecture
+
+The Linux and macOS scripts default to the host architecture. Override the
+target architecture with:
+
+```bash
+MLC_DOXYGEN_BIN_ARCH=aarch64 scripts/wheel_manylinux_2_28_v1_17_0.sh
+MLC_DOXYGEN_BIN_ARCH=arm64 scripts/wheel_macos_v1_17_0.sh
+```
+
+Supported values are:
+
+- Linux: `x86_64`, `aarch64`
+- macOS: `arm64`, `x86_64`
+- Windows: `AMD64`
+
+## Build Dependencies
+
+The build needs CMake, Ninja, Python, Flex, Bison, and a C++ compiler. The
+manylinux script installs Bison from the manylinux distribution and builds a
+pinned Flex 2.6.4 into `/usr/local`, because AlmaLinux 8's Flex 2.6.1 can fail
+while generating Doxygen's large scanners.
+
+On macOS, use Homebrew Flex and Bison if the Apple-provided versions are too
+old:
+
+```bash
+brew install flex bison
+```
+
+The macOS script automatically prepends Homebrew's `flex` and `bison`
+directories to `PATH` when Homebrew is available.
+
+On Windows, install Visual Studio Build Tools and `winflexbison3`.
+
+## Runtime Scope
+
+This package intentionally builds only the Doxygen CLI executable. It does not
+bundle `doxywizard`, `doxyindexer`, `doxysearch.cgi`, libclang, Graphviz,
+LaTeX, Ghostscript, or PlantUML. Those tools remain external runtime
+dependencies for Doxygen features that need them.
+
+## Usage
+
+```bash
+python -m pip install mlc-doxygen-bin==1.17.0
+doxygen --version
+```
+
+Programmatic path lookup is also available:
+
+```python
+import mlc_doxygen_bin
+
+print(mlc_doxygen_bin.get_executable_path())
+print(mlc_doxygen_bin.metadata())
+```

mlc_doxygen_bin-1.17.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = [
+  "setuptools>=77",
+  "wheel>=0.43",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mlc-doxygen-bin"
+version = "1.17.0"
+description = "Prebuilt Doxygen 1.17.0 command-line executable"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "GPL-2.0-only"
+authors = [{ name = "MLC AI", email = "mlc.ai.dev@gmail.com" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Documentation",
+  "Topic :: Software Development :: Documentation",
+]
+
+[project.urls]
+Doxygen = "https://github.com/doxygen/doxygen"
+Repository = "https://github.com/mlc-ai/package"
+
+[project.scripts]
+doxygen = "mlc_doxygen_bin.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+zip-safe = false
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+mlc_doxygen_bin = [
+  "py.typed",
+  "*.json",
+  "bin/*",
+  "licenses/*",
+]
+
+[tool.cibuildwheel]
+# CIBW_BUILD selects the Python used to run the build. setup.py overrides the
+# output wheel tag to py3-none because this package exposes a native executable,
+# not a CPython ABI extension.
+build = "cp311-*"
+build-frontend = "build"
+build-verbosity = 1
+skip = "*-musllinux_*"
+before-build = "python -m pip install cmake ninja && python scripts/prepare_doxygen_v1_17_0.py"
+test-command = "python {project}/scripts/smoke_test_mlc_doxygen_bin.py"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+before-all = "bash scripts/install_manylinux_build_tools.sh"
+repair-wheel-command = "python scripts/copy_wheel.py {wheel} {dest_dir}"
+
+[tool.cibuildwheel.macos]
+repair-wheel-command = "python scripts/copy_wheel.py {wheel} {dest_dir}"
+
+[tool.cibuildwheel.windows]
+repair-wheel-command = "python scripts/copy_wheel.py {wheel} {dest_dir}"

mlc_doxygen_bin-1.17.0/scripts/cibuildwheel_run.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$#" -lt 1 || "$#" -gt 3 ]]; then
+  echo "usage: cibuildwheel_run.sh <platform> [output-dir] [package-dir]" >&2
+  exit 1
+fi
+
+platform="$1"
+output_dir="${2:-wheelhouse}"
+package_dir="${3:-.}"
+
+: "${UV:=uv}"
+if ! command -v "${UV}" >/dev/null 2>&1; then
+  echo "uv executable not found: ${UV}" >&2
+  exit 1
+fi
+
+"${UV}" tool run --isolated --from "cibuildwheel==3.3.1" \
+  cibuildwheel --platform "${platform}" --output-dir "${output_dir}" "${package_dir}"

mlc_doxygen_bin-1.17.0/scripts/copy_wheel.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    if len(sys.argv) != 3:
+        raise SystemExit("usage: copy_wheel.py <wheel> <dest-dir>")
+    wheel = Path(sys.argv[1]).resolve()
+    dest_dir = Path(sys.argv[2]).resolve()
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(wheel, dest_dir / wheel.name)
+
+
+if __name__ == "__main__":
+    main()

mlc_doxygen_bin-1.17.0/scripts/install_manylinux_build_tools.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+flex_version="2.6.4"
+flex_url="https://github.com/westes/flex/releases/download/v${flex_version}/flex-${flex_version}.tar.gz"
+flex_sha256="e87aae032bf07c26f85ac0ed3250998c37621d95f8bd748b31f15b33c45ee995"
+
+: "${MLC_DOXYGEN_BIN_TOOLS_PREFIX:=/usr/local}"
+
+if command -v yum >/dev/null 2>&1; then
+  yum install -y bison m4 make gcc gcc-c++ curl tar gzip
+elif command -v dnf >/dev/null 2>&1; then
+  dnf install -y bison m4 make gcc gcc-c++ curl tar gzip
+else
+  echo "Neither yum nor dnf is available; cannot install manylinux build tools" >&2
+  exit 1
+fi
+
+if [[ -x "${MLC_DOXYGEN_BIN_TOOLS_PREFIX}/bin/flex" ]]; then
+  installed_version="$("${MLC_DOXYGEN_BIN_TOOLS_PREFIX}/bin/flex" --version | sed -n '1s/.* \([0-9][0-9.]*\).*/\1/p')"
+  if [[ "${installed_version}" == "${flex_version}" ]]; then
+    "${MLC_DOXYGEN_BIN_TOOLS_PREFIX}/bin/flex" --version
+    bison --version | sed -n '1p'
+    exit 0
+  fi
+fi
+
+work_dir="$(mktemp -d)"
+cleanup() {
+  rm -rf "${work_dir}"
+}
+trap cleanup EXIT
+
+cd "${work_dir}"
+curl -fsSL --connect-timeout 10 --retry 5 -o "flex-${flex_version}.tar.gz" "${flex_url}"
+echo "${flex_sha256}  flex-${flex_version}.tar.gz" | sha256sum -c -
+tar -xzf "flex-${flex_version}.tar.gz"
+cd "flex-${flex_version}"
+
+# Flex 2.6.4 detects reallocarray on manylinux_2_28, but GCC 14 builds fail
+# unless glibc exposes its declaration. Keep the feature macro explicit instead
+# of suppressing implicit-function-declaration diagnostics.
+export CFLAGS="${CFLAGS:-} -D_GNU_SOURCE"
+
+./configure --prefix="${MLC_DOXYGEN_BIN_TOOLS_PREFIX}" --disable-shared --enable-static
+make -j"$(nproc)"
+make install
+
+"${MLC_DOXYGEN_BIN_TOOLS_PREFIX}/bin/flex" --version
+bison --version | sed -n '1p'

mlc_doxygen_bin-1.17.0/scripts/prepare_doxygen_v1_17_0.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+import shlex
+import shutil
+import subprocess
+import sys
+import tarfile
+import urllib.request
+from pathlib import Path
+
+DOXYGEN_VERSION = "1.17.0"
+DOXYGEN_TAG = "Release_1_17_0"
+DOXYGEN_ARCHIVE_URL = (
+    "https://github.com/doxygen/doxygen/releases/download/"
+    f"{DOXYGEN_TAG}/doxygen-{DOXYGEN_VERSION}.src.tar.gz"
+)
+DOXYGEN_ARCHIVE_SHA256 = "fa4c3dd78785abc11ccc992bc9c01e7a8c3120fe14b8a8dfd7cefa7014530814"
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_PACKAGE_DIR = PROJECT_ROOT / "src" / "mlc_doxygen_bin"
+
+
+def run(cmd: list[str | Path], *, cwd: Path | None = None) -> None:
+    printable = " ".join(shlex.quote(str(part)) for part in cmd)
+    print(f"+ {printable}", flush=True)
+    subprocess.run([str(part) for part in cmd], cwd=cwd, check=True)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def verify_archive(path: Path) -> bool:
+    if not path.is_file():
+        return False
+    actual = sha256(path)
+    if actual == DOXYGEN_ARCHIVE_SHA256:
+        return True
+    print(f"Discarding {path}: expected {DOXYGEN_ARCHIVE_SHA256}, got {actual}", flush=True)
+    path.unlink()
+    return False
+
+
+def download_source_archive(work_root: Path) -> Path:
+    archive = work_root / f"doxygen-{DOXYGEN_VERSION}.src.tar.gz"
+    if verify_archive(archive):
+        return archive
+
+    tmp = archive.with_suffix(".tmp")
+    tmp.unlink(missing_ok=True)
+    print(f"Downloading Doxygen {DOXYGEN_VERSION} source from {DOXYGEN_ARCHIVE_URL}", flush=True)
+    with urllib.request.urlopen(DOXYGEN_ARCHIVE_URL, timeout=60) as response, tmp.open("wb") as dest:
+        shutil.copyfileobj(response, dest)
+    actual = sha256(tmp)
+    if actual != DOXYGEN_ARCHIVE_SHA256:
+        tmp.unlink(missing_ok=True)
+        raise RuntimeError(
+            "Doxygen source archive SHA-256 mismatch: "
+            f"expected {DOXYGEN_ARCHIVE_SHA256}, got {actual}"
+        )
+    tmp.replace(archive)
+    return archive
+
+
+def safe_extract(archive: Path, source_root: Path) -> Path:
+    source_dir = source_root / f"doxygen-{DOXYGEN_VERSION}"
+    if (source_dir / "CMakeLists.txt").is_file():
+        return source_dir
+
+    extract_dir = source_root / "_extract"
+    if extract_dir.exists():
+        shutil.rmtree(extract_dir)
+    extract_dir.mkdir(parents=True, exist_ok=True)
+
+    base = extract_dir.resolve()
+    with tarfile.open(archive, "r:gz") as tar:
+        members = tar.getmembers()
+        for member in members:
+            target = (extract_dir / member.name).resolve()
+            if target != base and base not in target.parents:
+                raise RuntimeError(f"Refusing to extract path outside destination: {member.name}")
+        extract_kwargs = {"filter": "data"} if hasattr(tarfile, "data_filter") else {}
+        tar.extractall(extract_dir, **extract_kwargs)
+
+    roots = [path for path in extract_dir.iterdir() if path.is_dir()]
+    if len(roots) != 1:
+        raise RuntimeError(f"Expected one root directory in {archive}, found {roots}")
+
+    if source_dir.exists():
+        shutil.rmtree(source_dir)
+    shutil.move(str(roots[0]), source_dir)
+    shutil.rmtree(extract_dir)
+    return source_dir
+
+
+def get_source_tree(work_root: Path) -> Path:
+    source_override = os.environ.get("MLC_DOXYGEN_BIN_SOURCE_DIR")
+    if source_override:
+        source_dir = Path(source_override).resolve()
+        if not (source_dir / "CMakeLists.txt").is_file():
+            raise RuntimeError(f"MLC_DOXYGEN_BIN_SOURCE_DIR is not a Doxygen source tree: {source_dir}")
+        return source_dir
+
+    archive = download_source_archive(work_root)
+    return safe_extract(archive, work_root / "src")
+
+
+def find_program(env_name: str, candidates: tuple[str, ...]) -> str | None:
+    configured = os.environ.get(env_name)
+    if configured:
+        return configured
+    if platform.system() == "Darwin":
+        brew = shutil.which("brew")
+        if brew:
+            for candidate in candidates:
+                result = subprocess.run(
+                    [brew, "--prefix", "--installed", candidate],
+                    check=False,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                )
+                if result.returncode == 0:
+                    path = Path(result.stdout.strip()) / "bin" / candidate
+                    if path.is_file():
+                        return str(path)
+    for candidate in candidates:
+        resolved = shutil.which(candidate)
+        if resolved:
+            return resolved
+    return None
+
+
+def cmake_configure_command(source_dir: Path, build_dir: Path, stage_dir: Path) -> list[str | Path]:
+    build_type = os.environ.get("MLC_DOXYGEN_BIN_BUILD_TYPE", "Release")
+    cmd: list[str | Path] = [
+        "cmake",
+        "-S",
+        source_dir,
+        "-B",
+        build_dir,
+    ]
+
+    generator = os.environ.get("MLC_DOXYGEN_BIN_CMAKE_GENERATOR")
+    if generator:
+        cmd.extend(["-G", generator])
+    elif platform.system() != "Windows" and shutil.which("ninja"):
+        cmd.extend(["-G", "Ninja"])
+
+    cmd.extend(
+        [
+            f"-DCMAKE_BUILD_TYPE={build_type}",
+            f"-DCMAKE_INSTALL_PREFIX={stage_dir}",
+            "-Dbuild_wizard=OFF",
+            "-Dbuild_app=OFF",
+            "-Dbuild_parse=OFF",
+            "-Dbuild_search=OFF",
+            "-Dbuild_doc=OFF",
+            "-Dbuild_doc_chm=OFF",
+            "-Duse_libclang=OFF",
+            "-Duse_sys_spdlog=OFF",
+            "-Duse_sys_fmt=OFF",
+            "-Duse_sys_sqlite3=OFF",
+        ]
+    )
+
+    flex = find_program("FLEX_EXECUTABLE", ("flex", "win_flex", "win_flex.exe"))
+    if flex:
+        cmd.append(f"-DFLEX_EXECUTABLE={flex}")
+    bison = find_program("BISON_EXECUTABLE", ("bison", "win_bison", "win_bison.exe"))
+    if bison:
+        cmd.append(f"-DBISON_EXECUTABLE={bison}")
+
+    if platform.system() == "Darwin":
+        deployment_target = os.environ.get("MACOSX_DEPLOYMENT_TARGET")
+        if deployment_target:
+            cmd.append(f"-DMACOS_VERSION_MIN={deployment_target}")
+            cmd.append(f"-DCMAKE_OSX_DEPLOYMENT_TARGET={deployment_target}")
+
+    if platform.system() == "Windows":
+        cmd.append("-Dwin_static=ON")
+
+    extra_args = os.environ.get("MLC_DOXYGEN_BIN_EXTRA_CMAKE_ARGS")
+    if extra_args:
+        cmd.extend(shlex.split(extra_args))
+
+    return cmd
+
+
+def executable_name() -> str:
+    return "doxygen.exe" if platform.system() == "Windows" else "doxygen"
+
+
+def validate_stage(stage_dir: Path) -> Path:
+    executable = stage_dir / "bin" / executable_name()
+    if not executable.is_file():
+        raise RuntimeError(f"Doxygen install tree is missing executable: {executable}")
+    return executable
+
+
+def clean_package_outputs(package_dir: Path) -> None:
+    for name in ("bin", "licenses"):
+        shutil.rmtree(package_dir / name, ignore_errors=True)
+    for name in ("doxygen.json",):
+        (package_dir / name).unlink(missing_ok=True)
+
+
+def copy_runtime(stage_dir: Path, package_dir: Path) -> Path:
+    source_bin = stage_dir / "bin"
+    dest_bin = package_dir / "bin"
+    shutil.copytree(source_bin, dest_bin)
+    executable = dest_bin / executable_name()
+    if platform.system() != "Windows":
+        executable.chmod(executable.stat().st_mode | 0o755)
+    return executable
+
+
+def rel(package_dir: Path, path: Path) -> str:
+    return path.relative_to(package_dir).as_posix()
+
+
+def write_version_file(package_dir: Path) -> None:
+    (package_dir / "_version.py").write_text(
+        (
+            f'__version__ = "{DOXYGEN_VERSION}"\n'
+            f'DOXYGEN_TAG = "{DOXYGEN_TAG}"\n'
+        ),
+        encoding="utf-8",
+    )
+
+
+def write_license(package_dir: Path, source_dir: Path) -> str:
+    licenses_dir = package_dir / "licenses"
+    licenses_dir.mkdir(parents=True, exist_ok=True)
+    source_license = source_dir / "LICENSE"
+    dest = licenses_dir / "LICENSE-Doxygen.txt"
+    if source_license.is_file():
+        shutil.copy2(source_license, dest)
+    else:
+        dest.write_text("See https://github.com/doxygen/doxygen/blob/master/LICENSE\n", encoding="utf-8")
+    return rel(package_dir, dest)
+
+
+def write_metadata(package_dir: Path, executable: Path, source_dir: Path, license_path: str) -> None:
+    metadata = {
+        "name": "doxygen",
+        "doxygen_version": DOXYGEN_VERSION,
+        "doxygen_tag": DOXYGEN_TAG,
+        "source_repository": "https://github.com/doxygen/doxygen",
+        "source_archive_url": DOXYGEN_ARCHIVE_URL,
+        "source_archive_sha256": DOXYGEN_ARCHIVE_SHA256,
+        "source_dir": str(source_dir),
+        "package_version": DOXYGEN_VERSION,
+        "executable": rel(package_dir, executable),
+        "license": license_path,
+        "features": {
+            "cli": True,
+            "doxywizard": False,
+            "search_tools": False,
+            "libclang": False,
+        },
+        "platform": platform.platform(),
+        "python": sys.version.split()[0],
+    }
+    (package_dir / "doxygen.json").write_text(
+        json.dumps(metadata, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def build_and_install(source_dir: Path, work_root: Path) -> Path:
+    build_dir = work_root / "build"
+    stage_dir = work_root / "stage"
+    if build_dir.exists():
+        shutil.rmtree(build_dir)
+    if stage_dir.exists():
+        shutil.rmtree(stage_dir)
+
+    run(cmake_configure_command(source_dir, build_dir, stage_dir))
+
+    build_type = os.environ.get("MLC_DOXYGEN_BIN_BUILD_TYPE", "Release")
+    build_cmd: list[str | Path] = [
+        "cmake",
+        "--build",
+        build_dir,
+        "--config",
+        build_type,
+        "--target",
+        "install",
+    ]
+    parallel = os.environ.get("CMAKE_BUILD_PARALLEL_LEVEL")
+    if parallel:
+        build_cmd.extend(["--parallel", parallel])
+    run(build_cmd)
+    validate_stage(stage_dir)
+    return stage_dir
+
+
+def main() -> None:
+    package_dir = Path(os.environ.get("MLC_DOXYGEN_BIN_PACKAGE_DIR", DEFAULT_PACKAGE_DIR)).resolve()
+    build_root = Path(
+        os.environ.get("MLC_DOXYGEN_BIN_BUILD_ROOT", PROJECT_ROOT / "build" / "doxygen-v1.17.0")
+    ).resolve()
+    package_dir.mkdir(parents=True, exist_ok=True)
+    build_root.mkdir(parents=True, exist_ok=True)
+
+    source_dir = get_source_tree(build_root)
+    clean_package_outputs(package_dir)
+    stage_dir = build_and_install(source_dir, build_root)
+    executable = copy_runtime(stage_dir, package_dir)
+    license_path = write_license(package_dir, source_dir)
+    write_version_file(package_dir)
+    write_metadata(package_dir, executable, source_dir, license_path)
+
+
+if __name__ == "__main__":
+    main()

mlc_doxygen_bin-1.17.0/scripts/smoke_test_mlc_doxygen_bin.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import mlc_doxygen_bin
+
+
+def run(cmd: list[str], *, cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    print("+ " + " ".join(cmd), flush=True)
+    return subprocess.run(cmd, cwd=cwd, check=True, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+
+def write_minimal_project(root: Path) -> Path:
+    source = root / "src"
+    output = root / "docs"
+    source.mkdir()
+    (source / "main.cpp").write_text(
+        """
+/// Adds two integers.
+int add(int left, int right) {
+  return left + right;
+}
+""".lstrip(),
+        encoding="utf-8",
+    )
+    doxyfile = root / "Doxyfile"
+    doxyfile.write_text(
+        f"""
+PROJECT_NAME = smoke
+OUTPUT_DIRECTORY = {output}
+INPUT = {source}
+QUIET = YES
+WARN_AS_ERROR = YES
+GENERATE_HTML = YES
+GENERATE_LATEX = NO
+HAVE_DOT = NO
+""".lstrip(),
+        encoding="utf-8",
+    )
+    return doxyfile
+
+
+def main() -> None:
+    executable = mlc_doxygen_bin.get_executable_path()
+    direct = run([executable, "--version"])
+    wrapped = run([sys.executable, "-m", "mlc_doxygen_bin", "--version"])
+    expected = mlc_doxygen_bin.__version__
+    if direct.stdout.strip() != expected:
+        raise RuntimeError(f"Expected direct Doxygen version {expected}, got {direct.stdout.strip()!r}")
+    if wrapped.stdout.strip() != expected:
+        raise RuntimeError(f"Expected wrapped Doxygen version {expected}, got {wrapped.stdout.strip()!r}")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        doxyfile = write_minimal_project(root)
+        run([sys.executable, "-m", "mlc_doxygen_bin", str(doxyfile)], cwd=root)
+        index = root / "docs" / "html" / "index.html"
+        if not index.is_file():
+            raise RuntimeError(f"Doxygen did not generate expected HTML index: {index}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as err:
+        print(f"smoke test failed: {err}", file=sys.stderr)
+        raise

mlc_doxygen_bin-1.17.0/scripts/wheel_macos_v1_17_0.sh

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${project_dir}"
+
+if [[ "$(uname -s)" != "Darwin" ]]; then
+  echo "wheel_macos_v1_17_0.sh must run on macOS" >&2
+  exit 1
+fi
+
+detect_python_org_version() {
+  pkgutil --pkgs \
+    | sed -n 's/^org\.python\.Python\.PythonFramework-\([0-9][0-9.]*\)$/\1/p' \
+    | sort -t. -k1,1n -k2,2n \
+    | tail -n 1
+}
+
+prepend_homebrew_tool() {
+  local formula="$1"
+  if command -v brew >/dev/null 2>&1; then
+    local prefix
+    if prefix="$(brew --prefix --installed "${formula}" 2>/dev/null)" && [[ -d "${prefix}/bin" ]]; then
+      PATH="${prefix}/bin:${PATH}"
+    fi
+  fi
+}
+
+prepend_homebrew_tool flex
+prepend_homebrew_tool bison
+export PATH
+
+host_arch="$(uname -m)"
+: "${MLC_DOXYGEN_BIN_ARCH:=${host_arch}}"
+case "${MLC_DOXYGEN_BIN_ARCH}" in
+  arm64|x86_64) ;;
+  *)
+    echo "Unsupported macOS architecture: ${MLC_DOXYGEN_BIN_ARCH}" >&2
+    exit 1
+    ;;
+esac
+
+for tool in flex bison; do
+  if ! command -v "${tool}" >/dev/null 2>&1; then
+    echo "${tool} is required to build Doxygen. Install it with: brew install flex bison" >&2
+    exit 1
+  fi
+done
+flex_executable="$(command -v flex)"
+bison_executable="$(command -v bison)"
+
+check_tool_version() {
+  local tool="$1"
+  local executable="$2"
+  local minimum="$3"
+  local actual
+  actual="$("${executable}" --version | sed -n '1s/.* \([0-9][0-9.]*\).*/\1/p')"
+  if [[ -z "${actual}" ]]; then
+    echo "Could not determine ${tool} version" >&2
+    exit 1
+  fi
+  python3 - "${tool}" "${actual}" "${minimum}" <<'PY'
+import re
+import sys
+
+tool, actual, minimum = sys.argv[1:]
+
+def parts(version):
+    return tuple(int(part) for part in re.findall(r"\d+", version))
+
+if parts(actual) < parts(minimum):
+    raise SystemExit(
+        f"{tool} {minimum} or newer is required to build Doxygen; found {actual}. "
+        "Install Homebrew flex and bison with: brew install flex bison"
+    )
+PY
+}
+
+check_tool_version flex "${flex_executable}" 2.5.37
+check_tool_version bison "${bison_executable}" 2.7
+
+if command -v sysctl >/dev/null 2>&1; then
+  cpu_count="$(sysctl -n hw.ncpu)"
+else
+  cpu_count="2"
+fi
+
+: "${MACOSX_DEPLOYMENT_TARGET:=13.0}"
+: "${CMAKE_BUILD_PARALLEL_LEVEL:=${cpu_count}}"
+
+platform_suffix="${MACOSX_DEPLOYMENT_TARGET//./_}_${MLC_DOXYGEN_BIN_ARCH}"
+: "${MLC_DOXYGEN_BIN_PLAT_NAME:=macosx_${platform_suffix}}"
+
+if [[ -z "${CIBW_BUILD:-}" ]]; then
+  python_org_version="$(detect_python_org_version)"
+  if [[ -z "${python_org_version}" ]]; then
+    cat >&2 <<'EOF'
+No python.org CPython installation was found.
+
+cibuildwheel on local macOS will not install CPython for you. Install one of
+the official python.org packages, then rerun this script. The wheel produced by
+this package is tagged py3-none, so the local build interpreter version only
+needs to be supported by cibuildwheel.
+EOF
+    exit 1
+  fi
+  python_tag="cp${python_org_version//./}"
+  export CIBW_BUILD="${python_tag}-macosx_${MLC_DOXYGEN_BIN_ARCH}"
+fi
+export CIBW_ARCHS_MACOS="${CIBW_ARCHS_MACOS:-${MLC_DOXYGEN_BIN_ARCH}}"
+export CIBW_BUILD_VERBOSITY="${CIBW_BUILD_VERBOSITY:-1}"
+export CIBW_ENVIRONMENT="${CIBW_ENVIRONMENT:-MLC_DOXYGEN_BIN_PLAT_NAME='${MLC_DOXYGEN_BIN_PLAT_NAME}' MACOSX_DEPLOYMENT_TARGET='${MACOSX_DEPLOYMENT_TARGET}' CMAKE_BUILD_PARALLEL_LEVEL='${CMAKE_BUILD_PARALLEL_LEVEL}' FLEX_EXECUTABLE='${flex_executable}' BISON_EXECUTABLE='${bison_executable}'}"
+
+scripts/cibuildwheel_run.sh macos wheelhouse .
+
+shopt -s nullglob
+wheels=(wheelhouse/*-py3-none-"${MLC_DOXYGEN_BIN_PLAT_NAME}".whl)
+if [[ "${#wheels[@]}" -eq 0 ]]; then
+  echo "No ${MLC_DOXYGEN_BIN_PLAT_NAME} wheels found in wheelhouse" >&2
+  exit 1
+fi
+for wheel in "${wheels[@]}"; do
+  filename="$(basename "${wheel}")"
+  case "${filename}" in
+    *-py3-none-*) ;;
+    *)
+      echo "Expected Python-agnostic py3-none wheel tag, got ${filename}" >&2
+      exit 1
+      ;;
+  esac
+done

mlc_doxygen_bin-1.17.0/scripts/wheel_manylinux_2_28_v1_17_0.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${project_dir}"
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+  echo "wheel_manylinux_2_28_v1_17_0.sh must run on Linux with Docker available" >&2
+  exit 1
+fi
+
+host_arch="$(uname -m)"
+if [[ "${host_arch}" == "arm64" ]]; then
+  host_arch="aarch64"
+fi
+
+: "${MLC_DOXYGEN_BIN_ARCH:=${host_arch}}"
+case "${MLC_DOXYGEN_BIN_ARCH}" in
+  x86_64|aarch64) ;;
+  *)
+    echo "Unsupported manylinux architecture: ${MLC_DOXYGEN_BIN_ARCH}" >&2
+    exit 1
+    ;;
+esac
+
+if command -v nproc >/dev/null 2>&1; then
+  cpu_count="$(nproc)"
+else
+  cpu_count="2"
+fi
+
+: "${CMAKE_BUILD_PARALLEL_LEVEL:=${cpu_count}}"
+: "${MLC_DOXYGEN_BIN_PLAT_NAME:=manylinux_2_28_${MLC_DOXYGEN_BIN_ARCH}}"
+: "${MLC_DOXYGEN_BIN_TOOLS_PREFIX:=/usr/local}"
+
+export CIBW_BUILD="${CIBW_BUILD:-cp311-manylinux_${MLC_DOXYGEN_BIN_ARCH}}"
+export CIBW_ARCHS_LINUX="${CIBW_ARCHS_LINUX:-${MLC_DOXYGEN_BIN_ARCH}}"
+export CIBW_MANYLINUX_X86_64_IMAGE="${CIBW_MANYLINUX_X86_64_IMAGE:-manylinux_2_28}"
+export CIBW_MANYLINUX_AARCH64_IMAGE="${CIBW_MANYLINUX_AARCH64_IMAGE:-manylinux_2_28}"
+export CIBW_BUILD_VERBOSITY="${CIBW_BUILD_VERBOSITY:-1}"
+export CIBW_ENVIRONMENT="${CIBW_ENVIRONMENT:-MLC_DOXYGEN_BIN_PLAT_NAME='${MLC_DOXYGEN_BIN_PLAT_NAME}' CMAKE_BUILD_PARALLEL_LEVEL='${CMAKE_BUILD_PARALLEL_LEVEL}' MLC_DOXYGEN_BIN_TOOLS_PREFIX='${MLC_DOXYGEN_BIN_TOOLS_PREFIX}' FLEX_EXECUTABLE='${MLC_DOXYGEN_BIN_TOOLS_PREFIX}/bin/flex' BISON_EXECUTABLE='/usr/bin/bison'}"
+
+scripts/cibuildwheel_run.sh linux wheelhouse .
+
+shopt -s nullglob
+wheels=(wheelhouse/*-py3-none-"${MLC_DOXYGEN_BIN_PLAT_NAME}".whl)
+if [[ "${#wheels[@]}" -eq 0 ]]; then
+  echo "No ${MLC_DOXYGEN_BIN_PLAT_NAME} wheels found in wheelhouse" >&2
+  exit 1
+fi
+for wheel in "${wheels[@]}"; do
+  filename="$(basename "${wheel}")"
+  case "${filename}" in
+    *-py3-none-*) ;;
+    *)
+      echo "Expected Python-agnostic py3-none wheel tag, got ${filename}" >&2
+      exit 1
+      ;;
+  esac
+done

mlc_doxygen_bin-1.17.0/scripts/wheel_windows_v1_17_0.ps1

@@ -0,0 +1,52 @@
+$ErrorActionPreference = "Stop"
+
+$ProjectDir = Split-Path -Parent $PSScriptRoot
+Set-Location $ProjectDir
+
+if (-not $env:MLC_DOXYGEN_BIN_ARCH) {
+  $env:MLC_DOXYGEN_BIN_ARCH = "AMD64"
+}
+if ($env:MLC_DOXYGEN_BIN_ARCH -ne "AMD64") {
+  throw "Unsupported Windows architecture: $env:MLC_DOXYGEN_BIN_ARCH"
+}
+
+if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
+  throw "uv executable not found"
+}
+if (-not (Get-Command win_flex -ErrorAction SilentlyContinue) -and -not (Get-Command flex -ErrorAction SilentlyContinue)) {
+  throw "winflexbison3 is required to build Doxygen. Install it with: choco install winflexbison3"
+}
+if (-not (Get-Command win_bison -ErrorAction SilentlyContinue) -and -not (Get-Command bison -ErrorAction SilentlyContinue)) {
+  throw "winflexbison3 is required to build Doxygen. Install it with: choco install winflexbison3"
+}
+
+if (-not $env:CMAKE_BUILD_PARALLEL_LEVEL) {
+  $env:CMAKE_BUILD_PARALLEL_LEVEL = [string]$env:NUMBER_OF_PROCESSORS
+}
+if (-not $env:MLC_DOXYGEN_BIN_PLAT_NAME) {
+  $env:MLC_DOXYGEN_BIN_PLAT_NAME = "win_amd64"
+}
+if (-not $env:CIBW_BUILD) {
+  $env:CIBW_BUILD = "cp311-win_amd64"
+}
+if (-not $env:CIBW_ARCHS_WINDOWS) {
+  $env:CIBW_ARCHS_WINDOWS = "AMD64"
+}
+if (-not $env:CIBW_BUILD_VERBOSITY) {
+  $env:CIBW_BUILD_VERBOSITY = "1"
+}
+if (-not $env:CIBW_ENVIRONMENT) {
+  $env:CIBW_ENVIRONMENT = "MLC_DOXYGEN_BIN_PLAT_NAME='$env:MLC_DOXYGEN_BIN_PLAT_NAME' CMAKE_BUILD_PARALLEL_LEVEL='$env:CMAKE_BUILD_PARALLEL_LEVEL'"
+}
+
+uv tool run --isolated --from "cibuildwheel==3.3.1" cibuildwheel --platform windows --output-dir wheelhouse .
+
+$Wheels = Get-ChildItem -Path wheelhouse -Filter "*-py3-none-$env:MLC_DOXYGEN_BIN_PLAT_NAME.whl"
+if ($Wheels.Count -eq 0) {
+  throw "No $env:MLC_DOXYGEN_BIN_PLAT_NAME wheels found in wheelhouse"
+}
+foreach ($Wheel in $Wheels) {
+  if ($Wheel.Name -notlike "*-py3-none-*") {
+    throw "Expected Python-agnostic py3-none wheel tag, got $($Wheel.Name)"
+  }
+}

mlc_doxygen_bin-1.17.0/setup.cfg

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

mlc_doxygen_bin-1.17.0/setup.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+
+from setuptools import setup
+from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
+
+
+class bdist_wheel(_bdist_wheel):
+    def finalize_options(self) -> None:
+        super().finalize_options()
+        self.root_is_pure = False
+        plat_name = os.environ.get("MLC_DOXYGEN_BIN_PLAT_NAME")
+        if plat_name:
+            self.plat_name = plat_name
+            self.plat_name_supplied = True
+
+    def get_tag(self) -> tuple[str, str, str]:
+        _python, _abi, plat = super().get_tag()
+        return "py3", "none", plat
+
+
+setup(
+    cmdclass={
+        "bdist_wheel": bdist_wheel,
+    },
+)

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin/__init__.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import json
+import platform
+from pathlib import Path
+from typing import Any
+
+from ._version import DOXYGEN_TAG, __version__
+
+__all__ = [
+    "__version__",
+    "DOXYGEN_TAG",
+    "get_bin_dir",
+    "get_executable_path",
+    "metadata",
+]
+
+
+def _package_dir() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def get_bin_dir() -> str:
+    path = _package_dir() / "bin"
+    if not path.is_dir():
+        raise FileNotFoundError(f"Doxygen bin directory is missing: {path}")
+    return str(path)
+
+
+def get_executable_path() -> str:
+    name = "doxygen.exe" if platform.system() == "Windows" else "doxygen"
+    path = Path(get_bin_dir()) / name
+    if not path.is_file():
+        raise FileNotFoundError(f"Doxygen executable is missing: {path}")
+    return str(path)
+
+
+def metadata() -> dict[str, Any]:
+    path = _package_dir() / "doxygen.json"
+    if not path.is_file():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin/__main__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin/_version.py

@@ -0,0 +1,2 @@
+__version__ = "1.17.0"
+DOXYGEN_TAG = "Release_1_17_0"

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin/cli.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+from . import get_executable_path
+
+
+def main() -> int:
+    cmd = [get_executable_path(), *sys.argv[1:]]
+    return subprocess.run(cmd, check=False).returncode

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin/py.typed

@@ -0,0 +1 @@
+

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: mlc-doxygen-bin
+Version: 1.17.0
+Summary: Prebuilt Doxygen 1.17.0 command-line executable
+Author-email: MLC AI <mlc.ai.dev@gmail.com>
+License-Expression: GPL-2.0-only
+Project-URL: Doxygen, https://github.com/doxygen/doxygen
+Project-URL: Repository, https://github.com/mlc-ai/package
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# mlc-doxygen-bin
+
+`mlc-doxygen-bin` builds platform wheels containing the Doxygen 1.17.0 command-line
+executable. It is intended for Python-driven build systems that want a pinned
+Doxygen binary without relying on a system package manager.
+
+The wheel installs a `doxygen` console script that delegates to the executable
+stored inside the Python package.
+
+## Build Wheels
+
+For Doxygen 1.17.0 on macOS:
+
+```bash
+scripts/wheel_macos_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on manylinux_2_28:
+
+```bash
+scripts/wheel_manylinux_2_28_v1_17_0.sh
+```
+
+For Doxygen 1.17.0 on Windows:
+
+```powershell
+scripts\wheel_windows_v1_17_0.ps1
+```
+
+The scripts run `cibuildwheel==3.3.1` through `uv`. During CIBW's
+`before-build` phase, `scripts/prepare_doxygen_v1_17_0.py` downloads the pinned
+upstream source archive, verifies its SHA-256 digest, builds the CLI executable,
+and copies the install tree into `src/mlc_doxygen_bin`.
+
+Build artifacts are written to `wheelhouse/`.
+
+## Platform And Architecture
+
+The Linux and macOS scripts default to the host architecture. Override the
+target architecture with:
+
+```bash
+MLC_DOXYGEN_BIN_ARCH=aarch64 scripts/wheel_manylinux_2_28_v1_17_0.sh
+MLC_DOXYGEN_BIN_ARCH=arm64 scripts/wheel_macos_v1_17_0.sh
+```
+
+Supported values are:
+
+- Linux: `x86_64`, `aarch64`
+- macOS: `arm64`, `x86_64`
+- Windows: `AMD64`
+
+## Build Dependencies
+
+The build needs CMake, Ninja, Python, Flex, Bison, and a C++ compiler. The
+manylinux script installs Bison from the manylinux distribution and builds a
+pinned Flex 2.6.4 into `/usr/local`, because AlmaLinux 8's Flex 2.6.1 can fail
+while generating Doxygen's large scanners.
+
+On macOS, use Homebrew Flex and Bison if the Apple-provided versions are too
+old:
+
+```bash
+brew install flex bison
+```
+
+The macOS script automatically prepends Homebrew's `flex` and `bison`
+directories to `PATH` when Homebrew is available.
+
+On Windows, install Visual Studio Build Tools and `winflexbison3`.
+
+## Runtime Scope
+
+This package intentionally builds only the Doxygen CLI executable. It does not
+bundle `doxywizard`, `doxyindexer`, `doxysearch.cgi`, libclang, Graphviz,
+LaTeX, Ghostscript, or PlantUML. Those tools remain external runtime
+dependencies for Doxygen features that need them.
+
+## Usage
+
+```bash
+python -m pip install mlc-doxygen-bin==1.17.0
+doxygen --version
+```
+
+Programmatic path lookup is also available:
+
+```python
+import mlc_doxygen_bin
+
+print(mlc_doxygen_bin.get_executable_path())
+print(mlc_doxygen_bin.metadata())
+```

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+scripts/cibuildwheel_run.sh
+scripts/copy_wheel.py
+scripts/install_manylinux_build_tools.sh
+scripts/prepare_doxygen_v1_17_0.py
+scripts/smoke_test_mlc_doxygen_bin.py
+scripts/wheel_macos_v1_17_0.sh
+scripts/wheel_manylinux_2_28_v1_17_0.sh
+scripts/wheel_windows_v1_17_0.ps1
+src/mlc_doxygen_bin/__init__.py
+src/mlc_doxygen_bin/__main__.py
+src/mlc_doxygen_bin/_version.py
+src/mlc_doxygen_bin/cli.py
+src/mlc_doxygen_bin/py.typed
+src/mlc_doxygen_bin.egg-info/PKG-INFO
+src/mlc_doxygen_bin.egg-info/SOURCES.txt
+src/mlc_doxygen_bin.egg-info/dependency_links.txt
+src/mlc_doxygen_bin.egg-info/entry_points.txt
+src/mlc_doxygen_bin.egg-info/not-zip-safe
+src/mlc_doxygen_bin.egg-info/top_level.txt

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doxygen = mlc_doxygen_bin.cli:main

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

mlc_doxygen_bin-1.17.0/src/mlc_doxygen_bin.egg-info/top_level.txt

@@ -0,0 +1 @@
+mlc_doxygen_bin