zig-zon 0.2.1__tar.gz → 0.2.3__tar.gz

{zig-zon-0.2.1 → zig-zon-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zig-zon
-Version: 0.2.1
+Version: 0.2.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>
@@ -10,6 +10,10 @@ Requires-Python: >=3.8
 Project-URL: Homepage, https://codeberg.org/dasimmet/python-zig-zon
 Project-URL: Issues, https://codeberg.org/dasimmet/python-zig-zon/issues
 Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Zig
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 
 # Python Zig Zon Parser
@@ -25,7 +29,7 @@ Depending on your OS, you may need the python development headers
 
 ## Usage
 
-install from source on pypi:
+install from source on <https://pypi.org/project/zig-zon>:
 
 ```bash
 pip install zig-zon
@@ -41,6 +45,23 @@ print(parsed)
 
 or, look at the [test file](https://codeberg.org/dasimmet/python-zig-zon/src/branch/main/src/test_zig_zon.py)
 
+## Supported values and their python type
+
+- `structs` -> `dict`
+- `tuples` -> `list`
+- `integer literals` -> `int`
+- `hex literals` -> `int`
+- `float literals` -> `float`
+- `booleans` -> `bool`
+- `null` -> `None`
+- `string literals` -> `str`
+- `bare enum literals` -> `str`
+- `quoted enum literals` -> `str`
+
+## Not supported values
+
+- `bigint`
+
 ## How it works
 
 The `zig build` commands produces a python source distribution archive ready

{zig-zon-0.2.1 → zig-zon-0.2.3}/build.zig

@@ -2,35 +2,13 @@ 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);
-    }
+    const ext_install_step = b.step("bdist-wheel", "build python extension module");
 
     // this generates a python sdist archive
     const sdist = zig_python_sdist.create(b, .{
@@ -38,21 +16,14 @@ pub fn build(b: *Build) void {
         .version = zon.version,
         .description = b.path("README.md"),
         .build = .{
-            .args = &.{ ext_install_step.name, b.fmt("-Doptimize={s}", .{@tagName(optimize)}) },
-        },
-        .extra_pkg_info = &.{
-            .{ .key = "Summary", .value = "a native cpython extension to parse zig object notation strings" },
-            .{ .key = "Author-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
-            .{ .key = "Maintainer-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
-            .{ .key = "License-Expression", .value = "MIT" },
-            .{ .key = "Keywords", .value = "zig,ziglang,cpython,native,sdist,zon" },
-            .{ .key = "Requires-Python", .value = ">=3.8" },
-            .{ .key = "Project-URL", .value = "Homepage, https://codeberg.org/dasimmet/python-zig-zon" },
-            .{ .key = "Project-URL", .value = "Issues, https://codeberg.org/dasimmet/python-zig-zon/issues" },
-            // .{ .key = "Requires-Python", .value = ">=3.8" },
-            .{ .key = "Classifier", .value = "Development Status :: 4 - Beta" },
+            .args = &.{
+                ext_install_step.name,
+                b.fmt("-Doptimize={s}", .{@tagName(optimize)}),
+            },
         },
+        .extra_pkg_info = @import("pkg-info.zon"),
         .files = &.{
+            .{ .src = b.path("pkg-info.zon"), .dest = "pkg-info.zon" },
             .{ .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" },
@@ -73,8 +44,29 @@ pub fn build(b: *Build) void {
         .{
             .sdist = sdist.getEmittedArchive(),
             .test_py = b.path("src/test_zig_zon.py"),
+            .twine_check = true,
             .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);
+
+    {
+        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,
+        });
+        zig_python_sdist.linkCPython(b, .{
+            .lib = lib,
+            .version = zon.version,
+            .optimize = .ReleaseSmall,
+        });
+        const ext_install = zig_python_sdist.installExtLib(b, lib);
+
+        ext_install_step.dependOn(&ext_install.step);
+    }
 }

{zig-zon-0.2.1 → zig-zon-0.2.3}/build.zig.zon

@@ -1,18 +1,19 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.2.1",
+    .version = "0.2.3",
     .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .zig_python_sdist = .{
-            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git#d3b3de8f114f891e0d62c923441bb925eb8014ae",
-            .hash = "zig_python_sdist-0.0.1-wjgdOg-SAACQzg1tSdozTV7Tg11rIzVRDlx-8XIzOFee",
+            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git?ref=0.0.2#3dd2c2eaf62a7007d6c257c357ded7911537621a",
+            .hash = "zig_python_sdist-0.0.2-wjgdOpyrAADPCiUfh4LoKFNZkHstj4a1bIyEuwnNKkcc",
         },
     },
     .paths = .{
         "src",
         "build.zig",
         "build.zig.zon",
+        "pkg-info.zon",
         "LICENSE",
         "README.md",
         "setup.py",

zig-zon-0.2.3/pkg-info.zon

@@ -0,0 +1,15 @@
+.{
+    .{ .key = "Summary", .value = "a native cpython extension to parse zig object notation strings" },
+    .{ .key = "Author-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "Maintainer-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "License-Expression", .value = "MIT" },
+    .{ .key = "Keywords", .value = "zig,ziglang,cpython,native,sdist,zon" },
+    .{ .key = "Requires-Python", .value = ">=3.8" },
+    .{ .key = "Project-URL", .value = "Homepage, https://codeberg.org/dasimmet/python-zig-zon" },
+    .{ .key = "Project-URL", .value = "Issues, https://codeberg.org/dasimmet/python-zig-zon/issues" },
+    .{ .key = "Classifier", .value = "Development Status :: 4 - Beta" },
+    .{ .key = "Classifier", .value = "Programming Language :: Python :: 3" },
+    .{ .key = "Classifier", .value = "Programming Language :: Zig" },
+    .{ .key = "Classifier", .value = "Intended Audience :: Developers" },
+    .{ .key = "Classifier", .value = "Topic :: Software Development :: Libraries" },
+}

{zig-zon-0.2.1 → zig-zon-0.2.3}/setup.py

@@ -39,10 +39,11 @@ class ZigBuildWheel(bdist_wheel):
         subprocess.check_call(build_cmd)
 
         os.makedirs(self.bdist_dir, exist_ok=True)
-        artifacts = glob.glob("zig-out/lib/*")
+        copy_pattern = "zig-out/{}".format(setup_json['build']['copy_pattern'])
+        artifacts = glob.glob(copy_pattern)
         if len(artifacts) == 0:
             raise Exception(
-                'no zig artifacts found in {}/zig-out/lib/*'.format(cwd))
+                'no zig artifacts found in {}/{}'.format(cwd, copy_pattern))
 
         for it in artifacts:
             shutil.copyfile(it, os.path.join(
@@ -55,6 +56,7 @@ setup(
     name=setup_json['name'],
     version=mkversion(setup_json['version']),
     cmdclass={'bdist_wheel': ZigBuildWheel},
+    install_requires=setup_json['install_requires'],
     setup_requires=[
         "setuptools",
         "wheel",

zig-zon-0.2.3/setup.zig.json

@@ -0,0 +1 @@
+{"name":"zig_zon","version":{"major":0,"minor":2,"patch":3,"pre":null,"build":null},"zig_version":{"major":0,"minor":16,"patch":0,"pre":null,"build":null},"build":{"args":["bdist-wheel","-Doptimize=Debug","--fork=zig-pkg/zig_python_sdist"],"requires":[],"copy_pattern":"lib/*"},"install_requires":[]}

{zig-zon-0.2.1 → zig-zon-0.2.3}/src/zig_zon.zig

@@ -26,20 +26,23 @@ pub var zigmodule = c.PyModuleDef{
 pub export fn PyInit_zig_zon() [*c]c.PyObject {
     const mod = c.PyModule_Create(&zigmodule);
     cpython.addVersion(mod);
-    cpython.addZigTargetTriple(mod);
+    cpython.addZigBuiltin(mod);
     return mod;
 }
 
 pub fn parse(self: [*]PyObject, args: [*]PyObject) callconv(.c) [*c]PyObject {
     _ = self;
-    var zon_txt: [*c]u8 = undefined;
-    if (!(c.PyArg_ParseTuple(args, "s", &zon_txt) != 0)) return null;
+    const zon_slice: [:0]u8 = zon_slice: {
+        var zon_txt: [*c]u8 = undefined;
+        if (!(c.PyArg_ParseTuple(args, "s", &zon_txt) != 0)) return null;
+        break :zon_slice std.mem.sliceTo(zon_txt, 0);
+    };
 
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
-    const ast = Ast.parse(arena, std.mem.sliceTo(zon_txt, 0), .zon) catch |err| {
+    const ast = Ast.parse(arena, zon_slice, .zon) catch |err| {
         const errstr = std.fmt.allocPrintSentinel(
             arena,
             "zig-zon ast error: {s}",
@@ -50,23 +53,25 @@ pub fn parse(self: [*]PyObject, args: [*]PyObject) callconv(.c) [*c]PyObject {
         return null;
     };
 
-    // TODO: use zoir instead of AST maybe?
-    // this is unused for now and instead i walk the AST, but i keep it in as a sanity check for now.
-    var zoir = ZonGen.generate(arena, ast, .{ .parse_str_lits = false }) catch |err| {
-        const errstr = std.fmt.allocPrintSentinel(
-            arena,
-            "zig-zon zoir error: {s}",
-            .{@errorName(err)},
-            0,
-        ) catch "";
-        c.PyErr_SetString(c.PyExc_Exception, errstr.ptr);
-        return null;
-    };
-    defer zoir.deinit(arena);
+    {
+        // TODO: use zoir instead of AST maybe?
+        // this is unused for now and instead i walk the AST myself, but i keep it in as a sanity check.
+        var zoir = ZonGen.generate(arena, ast, .{ .parse_str_lits = false }) catch |err| {
+            const errstr = std.fmt.allocPrintSentinel(
+                arena,
+                "zig-zon zoir error: {s}",
+                .{@errorName(err)},
+                0,
+            ) catch "";
+            c.PyErr_SetString(c.PyExc_Exception, errstr.ptr);
+            return null;
+        };
+        defer zoir.deinit(arena);
+    }
 
     const main_node_index = ast.nodeData(.root).node;
 
-    return parseZon(arena, ast, main_node_index) catch |err| {
+    return parseZonAst(arena, ast, main_node_index) catch |err| {
         const errstr = std.fmt.allocPrintSentinel(
             arena,
             "zig-zon parse error: {s}",
@@ -86,10 +91,11 @@ const ZonError = error{
     StructExpected,
     StructIdentifierExpected,
     NotImplemented,
-    ZonArrayError,
+    ZonArrayInitFailed,
+    InvalidLiteral, // from quoted enum literal parse function
 } || IdentifierError || NumberLiteralError;
 
-fn parseZon(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObject {
+fn parseZonAst(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObject {
     const node_tag = tree.nodeTag(node);
     switch (node_tag) {
         .struct_init_comma,
@@ -114,8 +120,13 @@ fn parseZon(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObj
             const name_token = tree.firstToken(node);
             const enum_name = tree.tokenSlice(name_token + 1);
             if (std.mem.startsWith(u8, enum_name, "@")) {
-                std.log.err("non bare enum literals not implemented: {s}", .{enum_name});
-                return error.NotImplemented;
+                assert(std.mem.startsWith(u8, enum_name, "@\""));
+                assert(std.mem.endsWith(u8, enum_name, "\""));
+                const enum_parsed_name = try std.zig.string_literal.parseAlloc(
+                    arena,
+                    enum_name[1..enum_name.len],
+                );
+                return c.Py_BuildValue("s#", enum_parsed_name.ptr, enum_parsed_name.len);
             }
 
             return c.Py_BuildValue("s#", enum_name.ptr, enum_name.len);
@@ -208,7 +219,7 @@ fn parseZonStruct(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c
     for (struct_init.ast.fields) |field_init| {
         const name_token = tree.firstToken(field_init) - 2;
         const field_name = try identifierTokenString(arena, tree, name_token);
-        const field_obj = try parseZon(arena, tree, field_init);
+        const field_obj = try parseZonAst(arena, tree, field_init);
         const set_result = c.PyDict_SetItemString(ret, field_name, field_obj);
         assert(set_result >= 0);
     }
@@ -221,13 +232,13 @@ fn parseZonArray(arena: Allocator, tree: Ast, node: Ast.Node.Index) !*c.PyObject
     const array_init = tree.fullArrayInit(&buf, node) orelse {
         const tok = tree.nodeMainToken(node);
         std.log.err("expected paths expression to be a list of strings, got: {d}", .{tok});
-        return error.ZonArrayError;
+        return error.ZonArrayInitFailed;
     };
 
     const ret = c.PyList_New(0);
 
     for (array_init.ast.elements) |elem_node| {
-        const field_ret = try parseZon(arena, tree, elem_node);
+        const field_ret = try parseZonAst(arena, tree, elem_node);
         assert(c.PyList_Append(ret, field_ret) >= 0);
     }
     return ret;
@@ -236,10 +247,10 @@ fn parseZonArray(arena: Allocator, tree: Ast, node: Ast.Node.Index) !*c.PyObject
 const IdentifierError = error{OutOfMemory} || StringLiteralError;
 
 fn identifierTokenString(arena: Allocator, ast: Ast, token: Ast.TokenIndex) IdentifierError![:0]const u8 {
-    std.debug.assert(ast.tokenTag(token) == .identifier);
+    assert(ast.tokenTag(token) == .identifier);
     const ident_name = ast.tokenSlice(token);
     if (!std.mem.startsWith(u8, ident_name, "@")) {
-        return try arena.dupeZ(u8, ident_name);
+        return try arena.dupeSentinel(u8, ident_name, 0);
     }
 
     var buf = std.ArrayListUnmanaged(u8).empty;

{zig-zon-0.2.1 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/build.zig

@@ -24,8 +24,6 @@ pub fn build(b: *Build) void {
 
     b.installArtifact(exe);
 
-    const cpython = CPython.find(b);
-
     const sdist_dummy = b.addLibrary(.{
         .name = "sdist_dummy",
         .root_module = b.createModule(.{
@@ -35,13 +33,14 @@ pub fn build(b: *Build) void {
         }),
         .linkage = .dynamic,
     });
-    cpython.link(b, .{
+
+    linkCPython(b, .{
         .lib = sdist_dummy,
         .version = zon.version,
     });
-    const install_ext = CPython.installExtLib(b, sdist_dummy);
+    const install_ext = installExtLib(b, sdist_dummy);
 
-    const build_ext_step = b.step("build-ext", "build the sdist dummy python module");
+    const build_ext_step = b.step("bdist-wheel", "build the sdist dummy python module");
     build_ext_step.dependOn(&install_ext.step);
 
     const sdist = SDistStep.createInternal(b, .{
@@ -50,54 +49,46 @@ pub fn build(b: *Build) void {
         .version = zon.version,
         .description = b.path("README.md"),
         .build = .{
-            .args = &.{build_ext_step.name},
-        },
-        .extra_pkg_info = &.{
-            .{ .key = "Summary", .value = "Just a Test" },
-            .{ .key = "Author-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
-            .{ .key = "Maintainer-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
-            .{ .key = "License-Expression", .value = "MIT" },
-            .{ .key = "Keywords", .value = "zig,ziglang,cpython,native,sdist" },
-            .{ .key = "Requires-Python", .value = ">=3.8" },
-            .{ .key = "Project-URL", .value = "Homepage, https://codeberg.org/dasimmet/zig-python-sdist" },
-            .{ .key = "Project-URL", .value = "Issues, https://codeberg.org/dasimmet/zig-python-sdist/issues" },
-            .{ .key = "Classifier", .value = "Development Status :: 4 - Beta" },
+            .args = &.{ build_ext_step.name, b.fmt("-Doptimize={s}", .{@tagName(optimize)}) },
         },
+        .extra_pkg_info = @import("pkg-info.zon"),
         .files = &.{
             .{ .src = b.path("build.zig.zon"), .dest = "build.zig.zon" },
             .{ .src = b.path("build.zig"), .dest = "build.zig" },
+            .{ .src = b.path("pkg-info.zon"), .dest = "pkg-info.zon" },
             .{ .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" },
         },
+        .install_requires = &.{"ruamel.yaml.clibz"},
         .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 sdist_install = sdist.install();
+    b.getInstallStep().dependOn(&sdist_install.step);
+    b.step("sdist", "only build and install sdist").dependOn(&sdist_install.step);
 
     const test_pip_install = VenvInstallTest.create(
         b,
         .{
             .sdist = sdist.getEmittedArchive(),
             .test_py = b.path("example/test_ext.py"),
+            .twine_check = true,
             .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 const linkCPython = CPython.link;
+pub const installExtLib = CPython.installExtLib;
+
 pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
     var opt = options;
     const sdist = b.dependencyFromBuildZig(@This(), .{
         .target = b.graph.host,
-        .optimize = .Debug,
+        .optimize = .ReleaseFast,
     });
     opt.sdist_builder = opt.sdist_builder orelse sdist.artifact("sdist-builder");
 
@@ -106,6 +97,7 @@ pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
         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("pkg-info.zon"), .dest = "zig-pkg/zig_python_sdist/pkg-info.zon" },
             .{ .src = sdist.path("README.md"), .dest = "zig-pkg/zig_python_sdist/README.md" },
             .{ .src = sdist.path("LICENSE"), .dest = "zig-pkg/zig_python_sdist/LICENSE" },
         };
@@ -121,7 +113,6 @@ pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
     {
         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(

{zig-zon-0.2.1 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/build.zig.zon

@@ -1,10 +1,11 @@
 .{
     .name = .zig_python_sdist,
-    .version = "0.0.1",
+    .version = "0.0.2",
     .minimum_zig_version = "0.17.0-dev.947+36069a2a7",
     .paths = .{
         "build.zig",
         "build.zig.zon",
+        "pkg-info.zon",
         "README.md",
         "LICENSE",
         "src",

zig-zon-0.2.3/zig-pkg/zig_python_sdist/pkg-info.zon

@@ -0,0 +1,11 @@
+.{
+    .{ .key = "Summary", .value = "Just a Test" },
+    .{ .key = "Author-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "Maintainer-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "License-Expression", .value = "MIT" },
+    .{ .key = "Keywords", .value = "zig,ziglang,cpython,native,sdist" },
+    .{ .key = "Requires-Python", .value = ">=3.8" },
+    .{ .key = "Project-URL", .value = "Homepage, https://codeberg.org/dasimmet/zig-python-sdist" },
+    .{ .key = "Project-URL", .value = "Issues, https://codeberg.org/dasimmet/zig-python-sdist/issues" },
+    .{ .key = "Classifier", .value = "Development Status :: 4 - Beta" },
+}

zig-zon-0.2.3/zig-pkg/zig_python_sdist/src/build/CPython.zig

@@ -0,0 +1,125 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Build = std.Build;
+const LazyPath = Build.LazyPath;
+const mem = std.mem;
+
+/// a module for building cpython extension libraries,
+/// linking them with system python headers and libs
+pub const CPython = @This();
+
+exe: LazyPath,
+
+pub fn find(b: *Build) *CPython {
+    const self = b.allocator.create(CPython) catch @panic("OOM");
+    self.* = .{
+        .exe = 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;
+        },
+    };
+    return self;
+}
+
+pub const LinkOptions = struct {
+    /// library to link against libpython
+    lib: *std.Build.Step.Compile,
+    version: ?[]const u8 = null,
+    python_exe: ?LazyPath = 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 link(b: *Build, options: LinkOptions) void {
+    const self: *const CPython = if (options.python_exe) |python_exe|
+        &.{ .exe = python_exe }
+    else
+        CPython.find(b);
+
+    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_include.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 generateIncludeDir(self: CPython, b: *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("pyinclude");
+}
+
+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 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});
+}
+
+// compat for 0.16.0 and 0.17.0
+pub fn findProgramCompat(b: *std.Build, names: []const []const u8) ?LazyPath {
+    if (comptime (@import("builtin").zig_version.order(std.SemanticVersion.parse("0.16.0") catch unreachable) == .gt)) {
+        return b.findProgramLazy(.{ .names = names });
+    }
+    return .{
+        .cwd_relative = b.findProgram(names, &.{}) catch return null,
+    };
+}