z3-static 4.16.0__tar.gz

z3_static-4.16.0/CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.26)
+project(z3_static LANGUAGES NONE)
+
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+
+if(NOT "$ENV{STATICLIB_Z3_ALLOW_SOURCE_BUILD}" STREQUAL "1")
+  message(FATAL_ERROR
+    "z3-static source builds are disabled by default. Install a prebuilt "
+    "wheel, or set STATICLIB_Z3_ALLOW_SOURCE_BUILD=1 to build Z3 from source "
+    "explicitly.")
+endif()
+
+set(Z3_STATICLIB_PACKAGE_DIR "${CMAKE_BINARY_DIR}/z3_static")
+set(Z3_STATICLIB_BUILD_ROOT "${CMAKE_BINARY_DIR}/z3-build")
+set(Z3_STATICLIB_TAG "$ENV{STATICLIB_Z3_TAG}")
+if(Z3_STATICLIB_TAG STREQUAL "")
+  set(Z3_STATICLIB_TAG "z3-4.16.0")
+endif()
+
+add_custom_target(stage_z3_static ALL
+  COMMAND
+    "${CMAKE_COMMAND}" -E env
+    "STATICLIB_Z3_TAG=${Z3_STATICLIB_TAG}"
+    "STATICLIB_Z3_PACKAGE_DIR=${Z3_STATICLIB_PACKAGE_DIR}"
+    "STATICLIB_Z3_BUILD_ROOT=${Z3_STATICLIB_BUILD_ROOT}"
+    "STATICLIB_Z3_SOURCE_DIR=$ENV{STATICLIB_Z3_SOURCE_DIR}"
+    "MACOSX_DEPLOYMENT_TARGET=$ENV{MACOSX_DEPLOYMENT_TARGET}"
+    "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/z3_static_builder.py"
+  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+  COMMENT "Building static Z3 artifacts"
+  VERBATIM
+)
+
+install(DIRECTORY "${Z3_STATICLIB_PACKAGE_DIR}/static" DESTINATION z3_static)
+

z3_static-4.16.0/LICENSE

@@ -0,0 +1,5 @@
+This package is distributed under the MIT License.
+
+The packaged Z3 artifacts are distributed under the upstream Z3 MIT License,
+which is included in the wheel as z3_static/static/LICENSE.Z3.
+

z3_static-4.16.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+recursive-include scripts *.py
+global-exclude __pycache__ *.py[cod]
+

z3_static-4.16.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: z3-static
+Version: 4.16.0
+Summary: Static Z3 development artifacts for native build systems
+Keywords: z3,smt,static-library,cmake
+Author-Email: MLC AI <mlc.ai.dev@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Project-URL: Repository, https://github.com/mlc-ai/package
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# z3-static
+
+`z3-static` is a Python package that carries native Z3 development artifacts
+for build systems. It does not provide Z3 Python bindings.
+
+The wheel contains:
+
+- Z3 C and C++ headers.
+- A PIC static Z3 library (`libz3.a` on Unix-like platforms, `.lib` on Windows).
+- Z3 CMake package files under `z3_static/static/lib/cmake/z3`.
+- Z3 pkg-config metadata when upstream install provides it.
+
+Build systems can locate the package from Python:
+
+```python
+import z3_static
+
+print(z3_static.get_cmake_dir())
+```
+
+## Local Build
+
+Build a wheel from an upstream Z3 tag:
+
+```bash
+STATICLIB_Z3_TAG=z3-4.16.0 \
+STATICLIB_Z3_ALLOW_SOURCE_BUILD=1 \
+python -m build --wheel
+```
+
+Use an existing Z3 checkout:
+
+```bash
+STATICLIB_Z3_TAG=z3-4.16.0 \
+STATICLIB_Z3_SOURCE_DIR=/path/to/z3 \
+STATICLIB_Z3_ALLOW_SOURCE_BUILD=1 \
+python -m build --wheel
+```
+
+Source builds are opt-in to avoid accidental long Z3 builds on unsupported
+platforms when pip cannot find a matching prebuilt wheel.
+

z3_static-4.16.0/README.md

@@ -0,0 +1,42 @@
+# z3-static
+
+`z3-static` is a Python package that carries native Z3 development artifacts
+for build systems. It does not provide Z3 Python bindings.
+
+The wheel contains:
+
+- Z3 C and C++ headers.
+- A PIC static Z3 library (`libz3.a` on Unix-like platforms, `.lib` on Windows).
+- Z3 CMake package files under `z3_static/static/lib/cmake/z3`.
+- Z3 pkg-config metadata when upstream install provides it.
+
+Build systems can locate the package from Python:
+
+```python
+import z3_static
+
+print(z3_static.get_cmake_dir())
+```
+
+## Local Build
+
+Build a wheel from an upstream Z3 tag:
+
+```bash
+STATICLIB_Z3_TAG=z3-4.16.0 \
+STATICLIB_Z3_ALLOW_SOURCE_BUILD=1 \
+python -m build --wheel
+```
+
+Use an existing Z3 checkout:
+
+```bash
+STATICLIB_Z3_TAG=z3-4.16.0 \
+STATICLIB_Z3_SOURCE_DIR=/path/to/z3 \
+STATICLIB_Z3_ALLOW_SOURCE_BUILD=1 \
+python -m build --wheel
+```
+
+Source builds are opt-in to avoid accidental long Z3 builds on unsupported
+platforms when pip cannot find a matching prebuilt wheel.
+

z3_static-4.16.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["scikit-build-core>=0.11", "cmake>=3.26", "ninja", "packaging"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "z3-static"
+dynamic = ["version"]
+description = "Static Z3 development artifacts for native build systems"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "MLC AI", email = "mlc.ai.dev@gmail.com" }]
+keywords = ["z3", "smt", "static-library", "cmake"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Build Tools",
+]
+
+[project.urls]
+Repository = "https://github.com/mlc-ai/package"
+
+[tool.scikit-build]
+cmake.version = ">=3.26"
+wheel.py-api = "py3"
+wheel.packages = ["z3_static"]
+
+[tool.scikit-build.metadata.version]
+provider = "scikit_build_core.metadata.regex"
+input = "z3_static/_version.py"
+

z3_static-4.16.0/scripts/smoke_test_staticlib.py

@@ -0,0 +1,69 @@
+"""Verify that CMake can consume the packaged static Z3 library."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import z3_static
+
+
+def run(cmd: list[str], *, cwd: Path) -> None:
+    print("+", " ".join(cmd), flush=True)
+    subprocess.check_call(cmd, cwd=cwd)
+
+
+def main() -> None:
+    cmake = shutil.which("cmake")
+    if not cmake:
+        raise RuntimeError("cmake is required")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        (root / "CMakeLists.txt").write_text(
+            """
+cmake_minimum_required(VERSION 3.20)
+project(z3_static_smoke LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+find_package(Z3 CONFIG REQUIRED)
+add_executable(smoke main.cc)
+target_link_libraries(smoke PRIVATE z3::libz3)
+""".strip()
+            + "\n"
+        )
+        (root / "main.cc").write_text(
+            """
+#include <z3++.h>
+
+int main() {
+  z3::context ctx;
+  z3::solver solver(ctx);
+  z3::expr x = ctx.int_const("x");
+  solver.add(x > 0);
+  return solver.check() == z3::sat ? 0 : 1;
+}
+""".strip()
+            + "\n"
+        )
+
+        build = root / "build"
+        env = os.environ.copy()
+        env["Z3_DIR"] = z3_static.get_cmake_dir()
+        run([cmake, "-S", str(root), "-B", str(build), f"-DZ3_DIR={z3_static.get_cmake_dir()}"], cwd=root)
+        if sys.platform == "win32":
+            run([cmake, "--build", str(build), "--config", "Release"], cwd=root)
+            exe = build / "Release" / "smoke.exe"
+        else:
+            run([cmake, "--build", str(build)], cwd=root)
+            exe = build / "smoke"
+        run([str(exe)], cwd=root)
+
+
+if __name__ == "__main__":
+    main()
+

z3_static-4.16.0/scripts/z3_static_builder.py

@@ -0,0 +1,145 @@
+"""Build and stage static Z3 development artifacts."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import urllib.request
+from pathlib import Path
+
+
+def _run(cmd: list[str], *, cwd: Path | None = None, env: dict[str, str] | None = None) -> None:
+    print("+", " ".join(cmd), flush=True)
+    subprocess.check_call(cmd, cwd=cwd, env=env)
+
+
+def _tool(name: str) -> str:
+    path = shutil.which(name)
+    if not path:
+        raise RuntimeError(f"Required tool not found on PATH: {name}")
+    return path
+
+
+def _download_source(tag: str, build_root: Path) -> Path:
+    archive = build_root / f"{tag}.tar.gz"
+    source_dir = build_root / f"z3-{tag}"
+    if source_dir.exists():
+        return source_dir
+
+    url = f"https://github.com/Z3Prover/z3/archive/refs/tags/{tag}.tar.gz"
+    print(f"Downloading {url}", flush=True)
+    urllib.request.urlretrieve(url, archive)
+
+    extract_dir = build_root / "src"
+    shutil.rmtree(extract_dir, ignore_errors=True)
+    extract_dir.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(archive, "r:gz") as tar:
+        tar.extractall(extract_dir)
+
+    children = [p for p in extract_dir.iterdir() if p.is_dir()]
+    if len(children) != 1:
+        raise RuntimeError(f"Expected one extracted Z3 source directory, got {children}")
+    children[0].rename(source_dir)
+    return source_dir
+
+
+def _copy_tree(src: Path, dst: Path) -> None:
+    if src.exists():
+        shutil.copytree(src, dst, dirs_exist_ok=True)
+
+
+def _normalize_metadata_library_dirs(static_dir: Path) -> None:
+    """Point staged CMake/pkg-config metadata at the normalized lib directory."""
+    metadata_files = [
+        *static_dir.glob("lib/cmake/z3/*.cmake"),
+        *static_dir.glob("lib/pkgconfig/*.pc"),
+    ]
+    for path in metadata_files:
+        text = path.read_text(encoding="utf-8")
+        normalized = text.replace("/lib64", "/lib")
+        if normalized != text:
+            path.write_text(normalized, encoding="utf-8")
+
+
+def main() -> None:
+    tag = os.environ.get("STATICLIB_Z3_TAG", "z3-4.16.0")
+    package_dir = Path(
+        os.environ.get("STATICLIB_Z3_PACKAGE_DIR", Path.cwd() / "build/local-package/z3_static")
+    ).resolve()
+    build_root = Path(os.environ.get("STATICLIB_Z3_BUILD_ROOT", Path.cwd() / "build/z3")).resolve()
+    source_env = os.environ.get("STATICLIB_Z3_SOURCE_DIR") or None
+
+    cmake = _tool("cmake")
+    ninja = _tool("ninja")
+
+    build_root.mkdir(parents=True, exist_ok=True)
+    source_dir = Path(source_env).resolve() if source_env else _download_source(tag, build_root)
+    if not source_dir.exists():
+        raise RuntimeError(f"Z3 source directory does not exist: {source_dir}")
+
+    build_dir = build_root / "build"
+    install_dir = build_root / "install"
+    shutil.rmtree(build_dir, ignore_errors=True)
+    shutil.rmtree(install_dir, ignore_errors=True)
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    cmake_args = [
+        cmake,
+        "-S",
+        str(source_dir),
+        "-B",
+        str(build_dir),
+        "-G",
+        "Ninja",
+        f"-DCMAKE_MAKE_PROGRAM={ninja}",
+        f"-DCMAKE_INSTALL_PREFIX={install_dir}",
+        "-DCMAKE_BUILD_TYPE=Release",
+        "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+        "-DBUILD_SHARED_LIBS=OFF",
+        "-DZ3_BUILD_LIBZ3_SHARED=OFF",
+        "-DZ3_BUILD_EXECUTABLE=OFF",
+        "-DZ3_BUILD_PYTHON_BINDINGS=OFF",
+        "-DZ3_BUILD_TEST_EXECUTABLES=OFF",
+    ]
+    if sys.platform == "darwin":
+        deployment_target = os.environ.get("MACOSX_DEPLOYMENT_TARGET") or "14.0"
+        cmake_args.append(f"-DCMAKE_OSX_DEPLOYMENT_TARGET={deployment_target}")
+    _run(cmake_args)
+    _run([cmake, "--build", str(build_dir), "--parallel"])
+    _run([cmake, "--install", str(build_dir)])
+
+    static_dir = package_dir / "static"
+    shutil.rmtree(static_dir, ignore_errors=True)
+    static_dir.mkdir(parents=True, exist_ok=True)
+
+    _copy_tree(install_dir / "include", static_dir / "include")
+    _copy_tree(install_dir / "lib", static_dir / "lib")
+    _copy_tree(install_dir / "lib64", static_dir / "lib")
+    _copy_tree(install_dir / "share", static_dir / "share")
+    _normalize_metadata_library_dirs(static_dir)
+
+    license_src = source_dir / "LICENSE.txt"
+    if not license_src.exists():
+        license_src = source_dir / "LICENSE"
+    if not license_src.exists():
+        raise RuntimeError("Could not find upstream Z3 license file")
+    shutil.copy2(license_src, static_dir / "LICENSE.Z3")
+
+    if not (static_dir / "include" / "z3++.h").exists():
+        raise RuntimeError("Z3 C++ header was not staged")
+    libs = list((static_dir / "lib").glob("libz3.a")) + list((static_dir / "lib").glob("*.lib"))
+    if not libs:
+        raise RuntimeError("Static Z3 library was not staged")
+    cmake_dirs = list((static_dir / "lib").glob("cmake/z3"))
+    if not cmake_dirs:
+        raise RuntimeError("Z3 CMake package files were not staged")
+
+    print(f"Staged Z3 static artifacts under {static_dir}", flush=True)
+
+
+if __name__ == "__main__":
+    main()
+

z3_static-4.16.0/z3_static/__init__.py

@@ -0,0 +1,28 @@
+"""Locate the packaged static Z3 development artifacts."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ._version import __version__
+
+
+def get_prefix() -> str:
+    """Return the packaged native artifact prefix."""
+    return str(Path(__file__).resolve().parent / "static")
+
+
+def get_cmake_dir() -> str:
+    """Return the Z3 CMake package directory."""
+    return str(Path(get_prefix()) / "lib" / "cmake" / "z3")
+
+
+def get_include_dir() -> str:
+    """Return the Z3 include directory."""
+    return str(Path(get_prefix()) / "include")
+
+
+def get_library_dir() -> str:
+    """Return the Z3 library directory."""
+    return str(Path(get_prefix()) / "lib")
+

z3_static-4.16.0/z3_static/_version.py

@@ -0,0 +1,4 @@
+"""Version generated from the upstream Z3 release tag."""
+
+__version__ = "4.16.0"
+