zig-zon 0.1.2__tar.gz → 0.2.0__tar.gz

zig-zon-0.2.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: zig-zon
+Version: 0.2.0
+Summary: 
+Description-Content-Type: text/markdown
+
+# Python Zig Zon Parser
+
+A native python extension built with zig to parse zig-object-notation strings
+into python objects.
+
+On PyPi it is only distributed in source, and built during install.
+It therefore needs to download the `ziglang` python package.
+
+Depending on your OS, you may need the python development headers
+(e.g. `python3-dev`) installed.
+
+## Usage
+
+install from source on pypi:
+
+```bash
+pip install zig-zon
+```
+
+running:
+
+```python
+import zig_zon
+parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
+print(parsed)
+```
+
+or, look at the [test file](https://codeberg.org/dasimmet/python-zig-zon/src/branch/main/src/test_zig_zon.py)
+
+## How it works
+
+The `zig build` commands produces a python source distribution archive ready
+for uploading to Pypi. It includes the sources of [zig-python-sdist](https://codeberg.org/dasimmet/zig-python-sdist)
+and a custom `setup.py` that handles the build of the cpython extension.
+
+When you run pip install, the source distribution is downloaded, and since
+this source distribution depends on the `ziglang` python package at build time,
+a `zig build` command is used to compile the extension.
+
+## Developing
+
+as opposed to other solutions for building cpython extensions in zig,
+i want to develop this using:
+
+```
+zig build
+```
+
+for linking against the local python installation [zig-python-sdist](https://codeberg.org/dasimmet/zig-python-sdist)
+runs a python script that imports the cpython headers into zig's build cache,
+run `translate-c` on the result and offers a `cpython` module to import
+in our zig code.
+On windows, the extension library is also linked against
+the python runtime static lib and renamed to a `.pyd` file for importing.

zig-zon-0.2.0/build.zig

@@ -0,0 +1,66 @@
+const std = @import("std");
+const Build = std.Build;
+const zig_python_sdist = @import("zig_python_sdist");
+const zon = @import("build.zig.zon");
+const CPython = @import("setuptools_zig_build").CPython;
+
+pub fn build(b: *Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // this target and section of our build is used at pip install time
+    const ext_install_step = b.step("pyext", "build python extension module");
+    {
+        const cpython = zig_python_sdist.CPython.find(b);
+
+        const lib = b.addLibrary(.{
+            .name = "zig_zon",
+            .root_module = b.addModule("zig_zon", .{
+                .root_source_file = b.path("src/zig_zon.zig"),
+                .target = target,
+                .optimize = optimize,
+            }),
+            .linkage = .dynamic,
+        });
+        cpython.link(b, .{
+            .lib = lib,
+            .version = zon.version,
+            .optimize = .ReleaseSmall,
+        });
+        const ext_install = zig_python_sdist.CPython.installExtLib(b, lib);
+
+        ext_install_step.dependOn(&ext_install.step);
+    }
+
+    // this generates a python sdist archive
+    const sdist = zig_python_sdist.create(b, .{
+        .name = "zig-zon",
+        .version = zon.version,
+        .description = b.path("README.md"),
+        .build_args = &.{ ext_install_step.name, b.fmt("-Doptimize={s}", .{@tagName(optimize)}) },
+        .files = &.{
+            .{ .src = b.path("build.zig.zon"), .dest = "build.zig.zon" },
+            .{ .src = b.path("build.zig"), .dest = "build.zig" },
+            .{ .src = b.path("src/zig_zon.zig"), .dest = "src/zig_zon.zig" },
+        },
+    });
+
+    const sdistfile = b.addInstallFileWithDir(
+        sdist.getEmittedArchive(),
+        .{ .custom = "src" },
+        sdist.basename,
+    );
+    b.getInstallStep().dependOn(&sdistfile.step);
+
+    // we can use a python virtual environment inside
+    // the zig cache to test pip installation
+    const test_pip_install = zig_python_sdist.VenvInstallTest.create(
+        b,
+        .{
+            .sdist = sdist.getEmittedArchive(),
+            .test_py = b.path("src/test_zig_zon.py"),
+            .no_clean = b.option(bool, "pip-no-clean", "dont cleanup pip temp dirs") orelse false,
+        },
+    );
+    b.step("test-pip-install", "").dependOn(test_pip_install.step);
+}

zig-zon-0.2.0/build.zig.zon

@@ -0,0 +1,21 @@
+.{
+    .name = .python_zig_zon,
+    .fingerprint = 0x3d332656a3644fc9,
+    .version = "0.2.0",
+    .minimum_zig_version = "0.16.0",
+    .dependencies = .{
+        .zig_python_sdist = .{
+            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git#509be1fcce025754c7bc6f0647802e79e195778b",
+            .hash = "zig_python_sdist-0.0.1-wjgdOo-NAAAH7qc0ulwksgbdgfrZ8bP4EhMw_ZRN1UtS",
+        },
+    },
+    .paths = .{
+        "src",
+        "build.zig",
+        "build.zig.zon",
+        "LICENSE",
+        "README.md",
+        "setup.py",
+        "pyproject.toml",
+    },
+}

zig-zon-0.2.0/setup.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+from setuptools.command.bdist_wheel import bdist_wheel
+import subprocess
+import sys
+import os
+import json
+import glob
+import shutil
+
+with open("setup.zig.json") as fd:
+    setup_json = json.load(fd)
+
+
+def mkversion(v, need_release=False):
+    if need_release:
+        assert v['pre'] == None, "cannot use version with pre: " + str(v)
+        assert v['build'] == None, "cannot use version with build: " + str(v)
+    return str(v['major']) + '.' + str(
+        v['minor']) + '.' + str(v['patch'])
+
+
+class ZigBuildWheel(bdist_wheel):
+    def run(self, *args, **kwargs):
+
+        import ziglang
+        zig_exe = os.path.join(
+            os.path.dirname(ziglang.__file__), "zig")
+
+        cwd = os.getcwd()
+        print("zig build dir:", cwd, file=sys.stderr)
+        print("using zig exe:", zig_exe, file=sys.stderr)
+
+        extra_build_args = setup_json['build']['args']
+        build_cmd = [zig_exe, 'build'] + extra_build_args
+
+        print("zig build:", build_cmd, file=sys.stderr)
+        subprocess.check_call(build_cmd)
+
+        os.makedirs(self.bdist_dir, exist_ok=True)
+        artifacts = glob.glob("zig-out/lib/*")
+        if len(artifacts) == 0:
+            raise Exception(
+                'no zig artifacts found in {}/zig-out/lib/*'.format(cwd))
+
+        for it in artifacts:
+            shutil.copyfile(it, os.path.join(
+                self.bdist_dir, os.path.basename(it)))
+
+        return super().run(*args, **kwargs)
+
+
+setup(
+    name=setup_json['name'],
+    version=mkversion(setup_json['version']),
+    cmdclass={'bdist_wheel': ZigBuildWheel},
+    setup_requires=[
+        "setuptools",
+        "wheel",
+        "ziglang==" + mkversion(setup_json['zig_version'], need_release=True),
+    ],
+)

zig-zon-0.2.0/setup.zig.json

@@ -0,0 +1 @@
+{"name":"zig_zon","version":{"major":0,"minor":2,"patch":0,"pre":null,"build":null},"zig_version":{"major":0,"minor":16,"patch":0,"pre":null,"build":null},"build":{"args":["pyext","-Doptimize=Debug","--fork=zig-pkg/zig_python_sdist"]}}

{zig_zon-0.1.2 → zig-zon-0.2.0}/src/zig_zon.zig

@@ -4,8 +4,8 @@ const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const ZonGen = std.zig.ZonGen;
 
-const python = @import("cpython");
-const c = python.c;
+const cpython = @import("cpython");
+const c = cpython.c;
 const PyObject = c.PyObject;
 
 pub var methods = [_]c.PyMethodDef{
@@ -25,7 +25,8 @@ pub var zigmodule = c.PyModuleDef{
 
 pub export fn PyInit_zig_zon() [*c]c.PyObject {
     const mod = c.PyModule_Create(&zigmodule);
-    python.addVersion(mod);
+    cpython.addVersion(mod);
+    cpython.addZigTargetTriple(mod);
     return mod;
 }
 
@@ -138,8 +139,8 @@ fn parseZon(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObj
                 return PyNone();
             } else {
                 if (@errorReturnTrace()) |et| {
-                    std.debug.dumpStackTrace(et.*);
-                    std.debug.dumpCurrentStackTrace(null);
+                    std.debug.dumpErrorReturnTrace(et);
+                    std.debug.dumpCurrentStackTrace(.{});
                 }
                 std.log.err("identifier not implemented: {any} '{s}'", .{ node_tag, token_slice });
                 return error.NotImplemented;
@@ -147,8 +148,8 @@ fn parseZon(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObj
         },
         else => {
             if (@errorReturnTrace()) |et| {
-                std.debug.dumpStackTrace(et.*);
-                std.debug.dumpCurrentStackTrace(null);
+                std.debug.dumpErrorReturnTrace(et);
+                std.debug.dumpCurrentStackTrace(.{});
             }
             const token_slice = tree.tokenSlice(tree.firstToken(node));
             std.log.err("zon ast token not implemented: {any} '{s}'", .{ node_tag, token_slice });

zig-zon-0.2.0/zig-pkg/zig_python_sdist/README.md

@@ -0,0 +1,7 @@
+# Zig Python Sdist
+
+this is a toolset to build python source distributions for pypi directly
+using `zig build`.
+
+It allows to add a python distribution to zig packages
+without dealing with python package metadata the traditional way.

zig-zon-0.2.0/zig-pkg/zig_python_sdist/build.zig

@@ -0,0 +1,135 @@
+const std = @import("std");
+const Build = std.Build;
+const LazyPath = Build.LazyPath;
+const zon = @import("build.zig.zon");
+
+pub const CPython = @import("src/build/CPython.zig");
+pub const VenvInstallTest = @import("src/build/VenvInstallTest.zig");
+pub const SDistStep = @import("src/build/SDistStep.zig");
+
+pub fn build(b: *Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const mod = b.addModule("sdist-builder", .{
+        .root_source_file = b.path("src/sdist_builder.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const exe = b.addExecutable(.{
+        .name = "sdist-builder",
+        .root_module = mod,
+    });
+
+    b.installArtifact(exe);
+
+    const cpython = CPython.find(b);
+
+    const sdist_dummy = b.addLibrary(.{
+        .name = "sdist_dummy",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("example/sdist_dummy.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+        .linkage = .dynamic,
+    });
+    cpython.link(b, .{
+        .lib = sdist_dummy,
+        .version = zon.version,
+    });
+    const install_ext = CPython.installExtLib(b, sdist_dummy);
+
+    const build_ext_step = b.step("build-ext", "build the sdist dummy python module");
+    build_ext_step.dependOn(&install_ext.step);
+
+    const sdist = SDistStep.createInternal(b, .{
+        .sdist_builder = exe,
+        .name = "zig-python-sdist-dummy",
+        .version = zon.version,
+        .description = b.path("README.md"),
+        .build_args = &.{build_ext_step.name}, // target name for pip zig build command
+        .files = &.{
+            .{ .src = b.path("build.zig.zon"), .dest = "build.zig.zon" },
+            .{ .src = b.path("build.zig"), .dest = "build.zig" },
+            .{ .src = b.path("example/sdist_dummy.zig"), .dest = "example/sdist_dummy.zig" },
+        },
+        .directories = &.{
+            .{ .src = b.path("src"), .dest = "src" },
+            .{ .src = b.path("src/build"), .dest = "src/build" },
+        },
+        .zig_version = std.SemanticVersion.parse("0.16.0") catch unreachable,
+    });
+
+    const sdistfile = b.addInstallFileWithDir(
+        sdist.getEmittedArchive(),
+        .{ .custom = "src" },
+        sdist.basename,
+    );
+    b.getInstallStep().dependOn(&sdistfile.step);
+
+    const test_pip_install = VenvInstallTest.create(
+        b,
+        .{
+            .sdist = sdist.getEmittedArchive(),
+            .test_py = b.path("example/test_ext.py"),
+            .no_clean = b.option(bool, "pip-no-clean", "cleanup pip temp dirs") orelse false,
+        },
+    );
+    b.step("test-pip-install", "").dependOn(test_pip_install.step);
+}
+
+pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
+    var opt = options;
+    const sdist = b.dependencyFromBuildZig(@This(), .{
+        .target = b.graph.host,
+        .optimize = .Debug,
+    });
+    opt.sdist_builder = opt.sdist_builder orelse sdist.artifact("sdist-builder");
+
+    {
+        var files: std.ArrayList(SDistStep.Content) = .empty;
+        const extra_files: []const SDistStep.Content = &.{
+            .{ .src = sdist.path("build.zig.zon"), .dest = "zig-pkg/zig_python_sdist/build.zig.zon" },
+            .{ .src = sdist.path("build.zig"), .dest = "zig-pkg/zig_python_sdist/build.zig" },
+            .{ .src = sdist.path("README.md"), .dest = "zig-pkg/zig_python_sdist/README.md" },
+            .{ .src = sdist.path("LICENSE"), .dest = "zig-pkg/zig_python_sdist/LICENSE" },
+        };
+        files.ensureTotalCapacity(
+            b.allocator,
+            opt.files.len + extra_files.len,
+        ) catch @panic("OOM");
+        files.appendSliceAssumeCapacity(opt.files);
+        files.appendSliceAssumeCapacity(extra_files);
+        opt.files = files.toOwnedSlice(b.allocator) catch @panic("OOM");
+    }
+
+    {
+        var dirs: std.ArrayList(SDistStep.Content) = .empty;
+        const extra_dirs: []const SDistStep.Content = &.{
+            // .{ .src = sdist.path("src"), .dest = "zig-pkg/zig_python_sdist/src" },
+            .{ .src = sdist.path("src/build"), .dest = "zig-pkg/zig_python_sdist/src/build" },
+        };
+        dirs.ensureTotalCapacity(
+            b.allocator,
+            opt.directories.len + extra_dirs.len,
+        ) catch @panic("OOM");
+        dirs.appendSliceAssumeCapacity(opt.directories);
+        dirs.appendSliceAssumeCapacity(extra_dirs);
+        opt.directories = dirs.toOwnedSlice(b.allocator) catch @panic("OOM");
+    }
+
+    {
+        var args: std.ArrayList([]const u8) = .empty;
+        args.ensureTotalCapacity(
+            b.allocator,
+            opt.build_args.len + 1,
+        ) catch @panic("OOM");
+        args.appendSliceAssumeCapacity(opt.build_args);
+        args.appendAssumeCapacity("--fork=zig-pkg/zig_python_sdist");
+        opt.build_args = args.toOwnedSlice(b.allocator) catch @panic("OOM");
+    }
+
+    return SDistStep.createInternal(b, opt);
+}

zig-zon-0.2.0/zig-pkg/zig_python_sdist/build.zig.zon

@@ -0,0 +1,13 @@
+.{
+    .name = .zig_python_sdist,
+    .version = "0.0.1",
+    .minimum_zig_version = "0.17.0-dev.947+36069a2a7",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "README.md",
+        "LICENSE",
+        "src",
+    },
+    .fingerprint = 0xbc2496e43a1d38c2,
+}

{zig_zon-0.1.2/.zig-dependencies/setuptools_zig_build-0.2.2-Ep6e3PA_AAD4M-tp4oSHJ1CvFBVqj3N87O67Z498MQwS/src → zig-zon-0.2.0/zig-pkg/zig_python_sdist/src/build}/CPython.zig

@@ -7,7 +7,6 @@ const mem = std.mem;
 pub const CPython = @This();
 
 exe: Build.LazyPath,
-version: ?[]const u8 = null,
 
 /// adds a `python` option to the build. if not provided, tries to find `python` in PATH
 pub fn findAddOption(b: *Build) *CPython {
@@ -26,10 +25,10 @@ pub fn findAddOption(b: *Build) *CPython {
 
 pub fn find(b: *Build) *CPython {
     const self = b.allocator.create(CPython) catch @panic("OOM");
-    const exe_path = FindExeWindowsCompat.findProgram(b, &.{
+    const exe_path = findProgramCompat(b, &.{
         "python",
         "python3",
-    }, &.{}) catch {
+    }) orelse {
         const err_wf = b.addWriteFiles();
         const err_step = b.addFail("finding python failed. please provide a path to the exe using -Dpython=");
         err_wf.step.dependOn(&err_step.step);
@@ -44,17 +43,12 @@ pub fn find(b: *Build) *CPython {
     return self;
 }
 
-pub fn addVersionOption(self: *CPython, b: *Build, fallback: []const u8) void {
-    self.version = b.option(
-        []const u8,
-        "version",
-        "set a version string",
-    ) orelse fallback;
-}
-
 pub const LinkOptions = struct {
     /// library to link against libpython
     lib: *std.Build.Step.Compile,
+    version: ?[]const u8 = null,
+    /// optimize mode for the c module. will fall back to lib's optimize mode.
+    optimize: ?std.builtin.OptimizeMode = null,
     macros: []const [2][]const u8 = &default_macros,
     pub const default_macros = .{
         .{ "Py_LIMITED_API", "0x03060500" }, // use the limited api from 3.6.5
@@ -69,58 +63,54 @@ pub fn generateIncludeDir(self: CPython, b: *Build) Build.LazyPath {
     return extract_link_info.addOutputDirectoryArg("include");
 }
 
-pub fn installExtLib(b: *Build, lib: *Build.Step.Compile) void {
+pub fn installExtLib(b: *Build, lib: *Build.Step.Compile) *Build.Step.InstallFile {
     const ext_lib_name = lib_ext_name(b, lib);
-    const lib_install = b.addInstallLibFile(lib.getEmittedBin(), ext_lib_name);
-    b.getInstallStep().dependOn(&lib_install.step);
+    return b.addInstallLibFile(lib.getEmittedBin(), ext_lib_name);
 }
 
-pub fn link(self: CPython, b: *Build, opt: LinkOptions) void {
+pub fn link(self: CPython, b: *Build, options: LinkOptions) void {
     const target = Build.ResolvedTarget{
         .query = .{},
-        .result = opt.lib.rootModuleTarget(),
+        .result = options.lib.rootModuleTarget(),
     };
 
     const python_inc = self.generateIncludeDir(b);
 
     const cpython = b.addTranslateC(.{
         .root_source_file = python_inc.path(b, "Zig_Python_With_Hexver.h"),
-        .optimize = opt.lib.root_module.optimize orelse .ReleaseSafe,
+        .optimize = options.optimize orelse options.lib.root_module.optimize orelse .ReleaseSafe,
         .target = target,
-        .link_libc = true,
     });
     cpython.addIncludePath(python_inc);
 
     const wf = b.addWriteFiles();
-    _ = wf.add("runtime.zig", @embedFile("runtime.zig"));
-    const pymod_lp = wf.add("python.zig", if (self.version == null)
-        \\pub const c = @import("c");
-        \\pub const runtime = @import("runtime.zig");
-    else
-        \\pub const c = @import("c");
-        \\pub const runtime = @import("runtime.zig");
-        \\pub const version = @embedFile("version.txt");
-        \\pub fn addVersion(mod: [*c]c.PyObject) void {
-        \\  runtime.addVersion(@This(), mod);
-        \\}
-        \\
-    );
-    if (self.version) |version| {
-        _ = wf.add("version.txt", version);
-    }
 
-    const pymod = b.createModule(.{ .root_source_file = pymod_lp });
-    pymod.addImport("c", cpython.createModule());
+    const pymod = b.createModule(.{
+        .root_source_file = wf.add("python.zig", @embedFile("python.zig")),
+        .imports = &.{
+            .{ .name = "c", .module = cpython.createModule() },
+        },
+    });
+
+    if (options.version) |version| {
+        pymod.addImport("version", b.createModule(.{
+            .root_source_file = wf.add("version.txt", version),
+        }));
+    } else {
+        pymod.addImport("version", b.createModule(.{
+            .root_source_file = wf.add("version.txt", "version not provided at configure time!"),
+        }));
+    }
 
-    for (opt.macros) |macro| {
+    for (options.macros) |macro| {
         cpython.defineCMacro(macro[0], macro[1]);
     }
 
     if (target.result.os.tag == .windows) {
-        opt.lib.root_module.addLibraryPath(python_inc);
-        opt.lib.linkSystemLibrary("python");
+        options.lib.root_module.addLibraryPath(python_inc);
+        options.lib.root_module.linkSystemLibrary("python", .{});
     }
-    opt.lib.root_module.addImport(
+    options.lib.root_module.addImport(
         "cpython",
         pymod,
     );
@@ -166,74 +156,6 @@ pub fn writeExtensionFile(b: *Build, lib: *Build.Step.Compile) Build.LazyPath {
     return wf.addCopyFile(lib.getEmittedBin(), ext_lib_name);
 }
 
-const FindExeWindowsCompat = struct {
-    fn tryFindProgram(b: *Build, full_path: []const u8) ?[]const u8 {
-        if (fs.realpathAlloc(b.allocator, full_path)) |p| {
-            return p;
-        } else |err| switch (err) {
-            error.OutOfMemory => @panic("OOM"),
-            else => {},
-        }
-
-        if (builtin.os.tag == .windows) {
-            if (b.graph.env_map.get("PATHEXT")) |PATHEXT| {
-                var it = mem.tokenizeScalar(u8, PATHEXT, fs.path.delimiter);
-
-                while (it.next()) |ext| {
-                    if (!supportedWindowsProgramExtension(ext)) continue;
-                    const exe_path = mem.join(b.allocator, "", &.{ full_path, ext }) catch @panic("OOM");
-                    fs.accessAbsolute(exe_path, .{ .mode = .read_only }) catch {
-                        b.allocator.free(exe_path);
-                        continue;
-                    };
-                    return exe_path;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    pub fn findProgram(b: *Build, names: []const []const u8, paths: []const []const u8) error{FileNotFound}![]const u8 {
-        // TODO report error for ambiguous situations
-        for (b.search_prefixes.items) |search_prefix| {
-            for (names) |name| {
-                if (fs.path.isAbsolute(name)) {
-                    return name;
-                }
-                return tryFindProgram(b, b.pathJoin(&.{ search_prefix, "bin", name })) orelse continue;
-            }
-        }
-        if (b.graph.env_map.get("PATH")) |PATH| {
-            for (names) |name| {
-                if (fs.path.isAbsolute(name)) {
-                    return name;
-                }
-                var it = mem.tokenizeScalar(u8, PATH, fs.path.delimiter);
-                while (it.next()) |p| {
-                    return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
-                }
-            }
-        }
-        for (names) |name| {
-            if (fs.path.isAbsolute(name)) {
-                return name;
-            }
-            for (paths) |p| {
-                return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
-            }
-        }
-        return error.FileNotFound;
-    }
-
-    fn supportedWindowsProgramExtension(ext: []const u8) bool {
-        inline for (@typeInfo(std.process.Child.WindowsExtension).@"enum".fields) |field| {
-            if (std.ascii.eqlIgnoreCase(ext, "." ++ field.name)) return true;
-        }
-        return false;
-    }
-};
-
 pub fn addSdistList(b: *Build) void {
     const wf = b.addWriteFiles();
     var wr: std.Io.Writer.Allocating = .init(b.allocator);
@@ -266,3 +188,11 @@ fn writeDeps(b: *std.Build, w: *std.json.Stringify) !void {
         }
     }
 }
+
+// compat for 0.16.0 and 0.17.0
+pub fn findProgramCompat(b: *std.Build, names: []const []const u8) ?[]const u8 {
+    if (comptime (@import("builtin").zig_version.order(std.SemanticVersion.parse("0.16.0") catch unreachable) == .gt)) {
+        return b.findProgram(.{ .names = names });
+    }
+    return b.findProgram(names, &.{}) catch null;
+}

zig-zon-0.2.0/zig-pkg/zig_python_sdist/src/build/LowerDashStringFormatter.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+str: []const u8,
+pub fn format(self: @This(), w: *std.Io.Writer) !void {
+    for (self.str) |char| {
+        if (char != '-') {
+            @branchHint(.likely);
+            try w.writeByte(char);
+        } else {
+            try w.writeByte('_');
+        }
+    }
+}