zig-zon 0.1.3__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.1.3 → zig-zon-0.2.0}/build.zig.zon

@@ -1,12 +1,12 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.1.3",
+    .version = "0.2.0",
     .minimum_zig_version = "0.16.0",
     .dependencies = .{
-        .setuptools_zig_build = .{
-            .url = "git+https://codeberg.org/dasimmet/setuptools-zig-build.git#9ce340bba4f54254aafa93dd492aa2d5c994b1b1",
-            .hash = "setuptools_zig_build-0.3.1-Ep6e3IE1AAAa8gtHLvqZUBeVJuKe0iB_eyutka4cw_EP",
+        .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 = .{

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.3 → 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;
 }
 

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.2.0/zig-pkg/zig_python_sdist/src/build/CPython.zig

@@ -0,0 +1,198 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Build = std.Build;
+const fs = std.fs;
+const mem = std.mem;
+
+pub const CPython = @This();
+
+exe: Build.LazyPath,
+
+/// adds a `python` option to the build. if not provided, tries to find `python` in PATH
+pub fn findAddOption(b: *Build) *CPython {
+    if (b.option(
+        Build.LazyPath,
+        "python",
+        "path to the cpython interpreter executable",
+    )) |opt| {
+        const self = b.allocator.create(CPython) catch @panic("OOM");
+        self.* = .{
+            .exe = opt,
+        };
+        return self;
+    } else return find(b);
+}
+
+pub fn find(b: *Build) *CPython {
+    const self = b.allocator.create(CPython) catch @panic("OOM");
+    const exe_path = findProgramCompat(b, &.{
+        "python",
+        "python3",
+    }) 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);
+        self.* = .{ .exe = err_wf.getDirectory() };
+        return self;
+    };
+    self.* = .{
+        .exe = .{
+            .cwd_relative = exe_path,
+        },
+    };
+    return self;
+}
+
+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
+    };
+};
+
+pub fn generateIncludeDir(self: CPython, b: *Build) Build.LazyPath {
+    const extract_link_info = Build.Step.Run.create(b, "python header extraction run");
+    extract_link_info.addFileArg(self.exe);
+    const wf = b.addWriteFiles();
+    extract_link_info.addFileArg(wf.add("extract_link_info.py", @embedFile("extract_link_info.py")));
+    return extract_link_info.addOutputDirectoryArg("include");
+}
+
+pub fn installExtLib(b: *Build, lib: *Build.Step.Compile) *Build.Step.InstallFile {
+    const ext_lib_name = lib_ext_name(b, lib);
+    return b.addInstallLibFile(lib.getEmittedBin(), ext_lib_name);
+}
+
+pub fn link(self: CPython, b: *Build, options: LinkOptions) void {
+    const target = Build.ResolvedTarget{
+        .query = .{},
+        .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 = options.optimize orelse options.lib.root_module.optimize orelse .ReleaseSafe,
+        .target = target,
+    });
+    cpython.addIncludePath(python_inc);
+
+    const wf = b.addWriteFiles();
+
+    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 (options.macros) |macro| {
+        cpython.defineCMacro(macro[0], macro[1]);
+    }
+
+    if (target.result.os.tag == .windows) {
+        options.lib.root_module.addLibraryPath(python_inc);
+        options.lib.root_module.linkSystemLibrary("python", .{});
+    }
+    options.lib.root_module.addImport(
+        "cpython",
+        pymod,
+    );
+}
+
+pub fn lib_ext_name(b: *Build, lib: *Build.Step.Compile) []const u8 {
+    const target = lib.rootModuleTarget();
+    return if (target.os.tag == .windows)
+        b.fmt("{s}.pyd", .{lib.name})
+    else
+        b.fmt("{s}.so", .{lib.name});
+}
+
+pub fn run_test(
+    self: CPython,
+    b: *Build,
+    lib: *Build.Step.Compile,
+    test_py_file: Build.LazyPath,
+) *Build.Step.Run {
+    const wf = b.addWriteFiles();
+    const python_runner = wf.add("python-runner.zig", @embedFile("python-runner.zig"));
+
+    const runner = b.addExecutable(.{
+        .name = "python-runner",
+        .root_module = b.createModule(.{
+            .root_source_file = python_runner,
+            .target = b.graph.host,
+            .optimize = .ReleaseSmall,
+        }),
+    });
+    const run_step = b.addRunArtifact(runner);
+    const python_ext = writeExtensionFile(b, lib);
+    run_step.addFileArg(self.exe);
+    run_step.addDirectoryArg(python_ext.dirname());
+    run_step.addFileArg(test_py_file);
+    run_step.has_side_effects = true;
+    return run_step;
+}
+
+pub fn writeExtensionFile(b: *Build, lib: *Build.Step.Compile) Build.LazyPath {
+    const ext_lib_name = lib_ext_name(b, lib);
+    const wf = b.addWriteFiles();
+    return wf.addCopyFile(lib.getEmittedBin(), ext_lib_name);
+}
+
+pub fn addSdistList(b: *Build) void {
+    const wf = b.addWriteFiles();
+    var wr: std.Io.Writer.Allocating = .init(b.allocator);
+    var jw: std.json.Stringify = .{ .writer = &wr.writer };
+    jw.beginObject() catch @panic("OOM");
+    if (b.graph.global_cache_root.path) |global_cache| {
+        jw.objectField("global_cache_dir") catch @panic("OOM");
+        jw.write(global_cache) catch @panic("OOM");
+    }
+
+    jw.objectField("dependencies") catch @panic("OOM");
+    jw.beginArray() catch @panic("OOM");
+    writeDeps(b, &jw) catch @panic("OOM");
+    jw.endArray() catch @panic("OOM");
+    jw.endObject() catch @panic("OOM");
+
+    const out = wf.add("sdistlist.json", wr.written());
+    const sdist_step = b.step("sdistlist", "generate a list of files for python sdist");
+    sdist_step.dependOn(&b.addInstallFile(out, "sdistlist.json").step);
+}
+
+fn writeDeps(b: *std.Build, w: *std.json.Stringify) !void {
+    for (b.available_deps) |dep| {
+        try w.beginArray();
+        try w.write(dep[0]);
+        try w.write(dep[1]);
+        try w.endArray();
+        if (b.lazyDependency(dep[0], .{})) |lazy_dep| {
+            try writeDeps(lazy_dep.builder, w);
+        }
+    }
+}
+
+// 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('_');
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+const std = @import("std");
+const Build = std.Build;
+const LazyPath = Build.LazyPath;
+const LowerDashStringFormatter = @import("LowerDashStringFormatter.zig");
+
+const SDistStep = @This();
+
+basename: []const u8,
+builder: *Build.Step.Compile,
+archive: LazyPath,
+pub const Content = struct {
+    src: LazyPath,
+    dest: []const u8,
+};
+pub const Options = struct {
+    name: []const u8,
+    version: []const u8,
+    description: ?LazyPath = null,
+    files: []const Content = &.{},
+    build_args: []const []const u8 = &.{},
+    directories: []const Content = &.{},
+    sdist_builder: ?*Build.Step.Compile = null,
+    // the version of the ziglang python package to depend on.
+    zig_version: ?std.SemanticVersion = null,
+};
+
+pub fn createInternal(b: *Build, options: Options) *SDistStep {
+    const self = b.allocator.create(SDistStep) catch @panic("OOM");
+    const basename = b.fmt("{f}-{s}.tar.gz", .{
+        LowerDashStringFormatter{ .str = options.name },
+        options.version,
+    });
+
+    const sdist_builder = options.sdist_builder orelse {
+        @panic("sdist_builder not set. use the top level .create() instead of .createInternal()!");
+    };
+
+    const run = b.addRunArtifact(sdist_builder);
+    run.addArg(b.fmt("--name={s}", .{options.name}));
+    run.addArg(b.fmt("--version={s}", .{options.version}));
+    if (options.description) |description| {
+        run.addPrefixedFileArg("--description=", description);
+    }
+
+    const zig_version = options.zig_version orelse @import("builtin").zig_version;
+    if (zig_version.build != null or zig_version.pre != null) {
+        std.log.warn("the python ziglang package is only published for releases.", .{});
+        std.log.warn("the resulting sdist might not be installable!", .{});
+        std.log.warn("set .zig_version for your sdist to a release explicitly", .{});
+    }
+
+    run.addArg(b.fmt("--zig-version={f}", .{zig_version}));
+
+    const archive = run.addPrefixedOutputFileArg("--output=", basename);
+    for (options.files) |content| {
+        run.addPrefixedFileArg("--file=", content.src);
+        run.addArg(content.dest);
+    }
+    for (options.directories) |content| {
+        run.addPrefixedDirectoryArg("--dir=", content.src);
+        run.addArg(content.dest);
+    }
+    for (options.build_args) |ba| {
+        run.addArg(b.fmt("--build={s}", .{ba}));
+    }
+
+    self.* = .{
+        .basename = basename,
+        .builder = sdist_builder,
+        .archive = archive,
+    };
+    return self;
+}
+
+pub fn getEmittedArchive(self: *SDistStep) LazyPath {
+    return self.archive;
+}

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

@@ -0,0 +1,76 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Build = std.Build;
+const LazyPath = Build.LazyPath;
+const CPython = @import("CPython.zig");
+
+const VenvInstallTest = @This();
+
+venv: *Build.Step.WriteFile,
+step: *Build.Step,
+install_run: *Build.Step.Run,
+pub const Options = struct {
+    sdist: LazyPath,
+    test_py: ?LazyPath = null,
+    // keeps intermediate pip directories. use for debugging installation
+    no_clean: bool,
+    // pass in python interpreter. uses system python if null
+    python: ?LazyPath = null,
+};
+
+pub fn create(b: *Build, options: Options) *VenvInstallTest {
+    const self = b.allocator.create(VenvInstallTest) catch @panic("OOM");
+
+    const wf = b.addWriteFiles();
+    wf.mode = .tmp;
+    self.venv = wf;
+
+    const venv_run = std.Build.Step.Run.create(b, "venv");
+    if (options.python) |python| {
+        venv_run.addFileArg(python);
+    } else {
+        if (CPython.findProgramCompat(b, &.{ "python", "python3" })) |python| {
+            venv_run.addArg(python);
+        } else {
+            venv_run.step.dependOn(&b.addFail("system python not found").step);
+        }
+    }
+    venv_run.addArgs(&.{ "-m", "venv" });
+    venv_run.addDirectoryArg(wf.getDirectory());
+    const venv_python = if (builtin.target.os.tag == .windows)
+        wf.getDirectory().path(b, "Scripts/python")
+    else
+        wf.getDirectory().path(b, "bin/python");
+
+    const deps_run = std.Build.Step.Run.create(b, "venv");
+    deps_run.addFileArg(venv_python);
+    deps_run.addArgs(&.{
+        "-m",
+        "pip",
+        "install",
+        "-U",
+        "pip",
+        "wheel",
+    });
+    deps_run.step.dependOn(&venv_run.step);
+
+    self.install_run = std.Build.Step.Run.create(b, "venv");
+    self.step = &self.install_run.step;
+
+    self.install_run.addFileArg(venv_python);
+    self.install_run.addArgs(&.{ "-m", "pip", "install", "--force-reinstall", "--verbose" });
+    if (options.no_clean) self.install_run.addArg("--no-clean");
+
+    self.install_run.step.dependOn(&deps_run.step);
+    self.install_run.addFileArg(options.sdist);
+
+    if (options.test_py) |test_py| {
+        const test_py_step = std.Build.Step.Run.create(b, "venv");
+        test_py_step.addFileArg(venv_python);
+        test_py_step.addFileArg(test_py);
+        self.step = &test_py_step.step;
+        test_py_step.step.dependOn(&self.install_run.step);
+    }
+
+    return self;
+}

zig-zon-0.2.0/zig-pkg/zig_python_sdist/src/build/extract_link_info.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+import sysconfig
+import sys
+import shutil
+import os
+
+output_dir = sys.argv[1]
+syspath = sysconfig.get_paths()
+
+lib_filename = 'python{}{}.lib'.format(
+    sys.version_info.major, sys.version_info.minor)
+
+os.makedirs(output_dir, exist_ok=True)
+shutil.copytree(syspath['include'], output_dir, dirs_exist_ok=True)
+
+found_lib = False
+sources = [syspath['include']]
+
+for k, v in sysconfig.get_config_vars().items():
+    if not isinstance(v, str):
+        continue
+    vf = os.path.join(v, lib_filename)
+    if os.path.exists(vf):
+        try:
+            shutil.copyfile(vf, os.path.join(output_dir, 'python.lib'))
+            found_lib = True
+            sources.append(vf)
+            break
+        except:
+            pass
+    else:
+        pass
+
+    vfl = os.path.join(v, 'libs', lib_filename)
+    if os.path.exists(vfl):
+        try:
+            shutil.copyfile(vfl, os.path.join(output_dir, 'python.lib'))
+            found_lib = True
+            sources.append(vfl)
+            break
+        except:
+            pass
+    else:
+        pass
+
+if sys.platform == 'windows' and not found_lib:
+    print("Warning: Did not find", lib_filename, "in:", file=sys.stderr)
+    print(lib_paths, file=sys.stderr)
+
+python_h = os.path.join(output_dir, 'Python.h')
+if not os.path.isfile(python_h):
+    raise Exception("Python.h missing! syspath include: {}\n output: {}".format(
+        syspath['include'], output_dir))
+
+output_header = os.path.join(output_dir, 'Zig_Python_With_Hexver.h')
+
+with open(output_header, 'w') as fd:
+    fd.write('''
+// Zig_Python_With_Hexver.h generated by extract_link_info.py
+// sources: {}
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#ifndef PYHEXVER
+#define PYHEXVER {}
+#endif
+
+#include "Python.h"
+'''.format(sources, sys.hexversion))
+    print('OK:', output_header)

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

@@ -0,0 +1,50 @@
+const std = @import("std");
+const builtin = @import("builtin");
+pub const c = @import("c");
+pub const version = @embedFile("version");
+
+pub fn addVersion(mod: [*c]c.PyObject) void {
+    const semver = comptime std.SemanticVersion.parse(version) catch {
+        @compileLog("could not parse version:");
+        @compileError(version);
+    };
+    const version_dict = c.PyDict_New();
+
+    _ = c.PyDict_SetItemString(version_dict, "major", c.Py_BuildValue("n", semver.major));
+    _ = c.PyDict_SetItemString(version_dict, "minor", c.Py_BuildValue("n", semver.minor));
+    _ = c.PyDict_SetItemString(version_dict, "patch", c.Py_BuildValue("n", semver.patch));
+    if (semver.pre) |pre| {
+        _ = c.PyDict_SetItemString(version_dict, "pre", c.Py_BuildValue("s#", pre.ptr, pre.len));
+    } else {
+        _ = c.PyDict_SetItemString(version_dict, "pre", c.Py_BuildValue(""));
+    }
+    if (semver.build) |build| {
+        _ = c.PyDict_SetItemString(version_dict, "build", c.Py_BuildValue("s#", build.ptr, build.len));
+    } else {
+        _ = c.PyDict_SetItemString(version_dict, "build", c.Py_BuildValue(""));
+    }
+    _ = c.PyObject_SetAttrString(
+        mod,
+        "__version__",
+        version_dict,
+    );
+
+    const version_str = c.Py_BuildValue("s#", version.ptr, version.len);
+    _ = c.PyObject_SetAttrString(
+        mod,
+        "__version_str__",
+        version_str,
+    );
+}
+
+pub fn addZigTargetTriple(mod: [*c]c.PyObject) void {
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    defer arena_instance.deinit();
+    const target_triple = builtin.target.zigTriple(arena_instance.allocator()) catch @panic("OOM");
+    const target_triple_str = c.Py_BuildValue("s#", target_triple.ptr, target_triple.len);
+    _ = c.PyObject_SetAttrString(
+        mod,
+        "__zig_target_triple__",
+        target_triple_str,
+    );
+}

zig_zon-0.1.3/MANIFEST.in

@@ -1,2 +0,0 @@
-exclude .gitlab-ci.yml
-exclude .gitignore

zig_zon-0.1.3/PKG-INFO

@@ -1,67 +0,0 @@
-Metadata-Version: 2.4
-Name: zig-zon
-Version: 0.1.3
-Summary: a native cpython extension to parse zig object notation strings
-Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
-Maintainer-email: Tobias Simetsreiter <dasimmet@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://codeberg.org/dasimmet/python-zig-zon
-Project-URL: Issues, https://codeberg.org/dasimmet/python-zig-zon/issues
-Keywords: zig,ziglang,zon,cpython
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# 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.
-
-## 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
-
-When you run pip install, the source distribution is downloaded, and since
-this package depends on the `ziglang` as well as my setuptools helper package:
-[setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-
-to execute `zig build` and put the resulting library in the wheel. 
-
-## Developing
-
-as opposed to other solutions for building cpython extensions in zig,
-i want to develop this using:
-
-```
-zig build test --watch
-```
-
-for linking against the local python installation [setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-runs a python script that imports the cpython headers into zig's build cache.
-When the module is built using `pip`, zig will get a `-Dpython=` option pointing to the correct python executable,
-otherwise system python in `PATH` is used.
-pip installation also uses a `-Dversion=` option for the pip package version.

zig_zon-0.1.3/README.md

@@ -1,48 +0,0 @@
-# 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.
-
-## 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
-
-When you run pip install, the source distribution is downloaded, and since
-this package depends on the `ziglang` as well as my setuptools helper package:
-[setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-
-to execute `zig build` and put the resulting library in the wheel. 
-
-## Developing
-
-as opposed to other solutions for building cpython extensions in zig,
-i want to develop this using:
-
-```
-zig build test --watch
-```
-
-for linking against the local python installation [setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-runs a python script that imports the cpython headers into zig's build cache.
-When the module is built using `pip`, zig will get a `-Dpython=` option pointing to the correct python executable,
-otherwise system python in `PATH` is used.
-pip installation also uses a `-Dversion=` option for the pip package version.

zig_zon-0.1.3/build.zig

@@ -1,36 +0,0 @@
-const std = @import("std");
-const Build = std.Build;
-
-const CPython = @import("setuptools_zig_build").CPython;
-
-pub fn build(b: *Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-    const python = CPython.findAddOption(b);
-    python.addVersionOption(b, @import("build.zig.zon").version);
-
-    CPython.addSdistList(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,
-        .use_llvm = true,
-    });
-    CPython.installExtLib(b, lib);
-
-    python.link(b, .{
-        .lib = lib,
-    });
-
-    const install_test = b.addInstallFile(b.path("src/test_zig_zon.py"), "lib/test_zig_zon.py");
-    b.step("install-test", "install the python test script alongside the built modules").dependOn(&install_test.step);
-
-    const run_test = python.run_test(b, lib, b.path("src/test_zig_zon.py"));
-
-    b.step("test", "run the python test script").dependOn(&run_test.step);
-}

zig_zon-0.1.3/pyproject.toml

@@ -1,32 +0,0 @@
-[project]
-name = "zig-zon"
-authors = [{ name = "Tobias Simetsreiter", email = "dasimmet@gmail.com" }]
-maintainers = [{ name = "Tobias Simetsreiter", email = "dasimmet@gmail.com" }]
-description = "a native cpython extension to parse zig object notation strings"
-readme = "README.md"
-requires-python = ">=3.9"
-dynamic = ["version"]
-license = "MIT"
-license-files = ["LICENSE"]
-keywords = ["zig", "ziglang", "zon", "cpython"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-]
-
-[project.urls]
-Homepage = "https://codeberg.org/dasimmet/python-zig-zon"
-Issues = "https://codeberg.org/dasimmet/python-zig-zon/issues"
-
-[build-system]
-requires = [
-    "setuptools",
-    "setuptools-scm",
-    "ziglang==0.16.0",
-    "setuptools-zig-build==0.3.1",
-]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools_scm]

zig_zon-0.1.3/sdistlist.json

@@ -1 +0,0 @@
-{"global_cache_dir":"/home/tobi/.cache/zig","dependencies":[["setuptools_zig_build","setuptools_zig_build-0.3.1-Ep6e3IE1AAAa8gtHLvqZUBeVJuKe0iB_eyutka4cw_EP"]]}

zig_zon-0.1.3/setup.cfg

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

zig_zon-0.1.3/setup.py

@@ -1,23 +0,0 @@
-from setuptools import Extension
-from setuptools import setup
-
-setup(
-    name='zig-zon',
-    packages=[],
-    zig_build={
-        # stores zig's depdendencies in python's sdist. requires a call to
-        # CPython.addSdistList(b); in `build.zig`
-        "sdist": True,
-        # tries to import 'ziglang' to get a zig compiler when building wheel
-        "use_ziglang_python_package": True,
-        # passes -Doptimize= to zig build
-        "optimize": "ReleaseSmall",
-        # passes -Dversion=<pip package version> to zig build
-        "pass_version_option": True,
-        # extra arguments to zig build
-        'extra_args': [
-            "install", "test",
-        ],
-    },
-    ext_modules=[Extension('zig_zon', [])],
-)

zig_zon-0.1.3/src/test_zig_zon.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-
-from pprint import pprint
-
-import zig_zon
-print('zig_zon module:', zig_zon)
-
-teststr = """
-.{
-    .asdf = "ccc",
-    .my_bool = true,
-    .my_float = 1.23,
-    .my_hex_int = 0xdeadbeef,
-    .my_negative_int = -432_123_111,
-    .my_negative_big_int = -4611686018427387904,
-    .my_optional = null,
-}"""
-
-testzon = zig_zon.parse(teststr)
-print('teststr:')
-pprint(testzon)
-pprint(zig_zon.__version__)
-pprint(zig_zon.__version_str__)
-
-assert testzon['asdf'] == "ccc"
-assert testzon['my_float'] == 1.23
-assert testzon['my_hex_int'] == 0xdeadbeef
-assert testzon['my_negative_int'] == -432_123_111
-assert testzon['my_negative_big_int'] == -4611686018427387904
-assert testzon['my_optional'] == None
-assert zig_zon.parse(str(2**63 - 1)) == 2**63 - 1
-assert zig_zon.parse(str(2**63)) == 2**63
-assert zig_zon.parse(str(2**64 - 1)) == 2**64 - 1
-
-# print("TODO: 2**64 ==", 2**64, ", zig_zon.parse(str(2**64)) ==",
-#       zig_zon.parse(str(2**64)))
-# assert zig_zon.parse(str(2**64)) == str(2**64)
-
-print('build.zig.zon:')
-with open('build.zig.zon') as fd:
-    pprint(zig_zon.parse(fd.read()))

zig_zon-0.1.3/zig_zon.egg-info/PKG-INFO

@@ -1,67 +0,0 @@
-Metadata-Version: 2.4
-Name: zig-zon
-Version: 0.1.3
-Summary: a native cpython extension to parse zig object notation strings
-Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
-Maintainer-email: Tobias Simetsreiter <dasimmet@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://codeberg.org/dasimmet/python-zig-zon
-Project-URL: Issues, https://codeberg.org/dasimmet/python-zig-zon/issues
-Keywords: zig,ziglang,zon,cpython
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# 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.
-
-## 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
-
-When you run pip install, the source distribution is downloaded, and since
-this package depends on the `ziglang` as well as my setuptools helper package:
-[setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-
-to execute `zig build` and put the resulting library in the wheel. 
-
-## Developing
-
-as opposed to other solutions for building cpython extensions in zig,
-i want to develop this using:
-
-```
-zig build test --watch
-```
-
-for linking against the local python installation [setuptools-zig-build](https://codeberg.org/dasimmet/setuptools-zig-build)
-runs a python script that imports the cpython headers into zig's build cache.
-When the module is built using `pip`, zig will get a `-Dpython=` option pointing to the correct python executable,
-otherwise system python in `PATH` is used.
-pip installation also uses a `-Dversion=` option for the pip package version.

zig_zon-0.1.3/zig_zon.egg-info/SOURCES.txt

@@ -1,13 +0,0 @@
-LICENSE
-MANIFEST.in
-README.md
-build.zig
-build.zig.zon
-pyproject.toml
-setup.py
-src/test_zig_zon.py
-src/zig_zon.zig
-zig_zon.egg-info/PKG-INFO
-zig_zon.egg-info/SOURCES.txt
-zig_zon.egg-info/dependency_links.txt
-zig_zon.egg-info/top_level.txt

zig_zon-0.1.3/zig_zon.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

zig_zon-0.1.3/zig_zon.egg-info/top_level.txt

@@ -1 +0,0 @@
-zig_zon