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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zig-zon
-Version: 0.2.3
+Version: 0.2.5
 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>
@@ -38,9 +38,10 @@ pip install zig-zon
 running:
 
 ```python
-import zig_zon
-parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
-print(parsed)
+>>> import zig_zon
+>>> parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
+>>> print(parsed)
+{'allyourcode': 'are_belong_to_us', 'asd': 123}
 ```
 
 or, look at the [test file](https://codeberg.org/dasimmet/python-zig-zon/src/branch/main/src/test_zig_zon.py)

zig-zon-0.2.5/build.zig

@@ -0,0 +1,118 @@
+const std = @import("std");
+const Build = std.Build;
+const zig_python_sdist = @import("zig_python_sdist");
+const zon = @import("build.zig.zon");
+
+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("bdist-wheel", "build python extension module");
+    ext_install_step.dependOn(
+        &b.addInstallFile(b.path("src/zig_zon.pyi"), "lib/zig_zon.pyi").step,
+    );
+
+    // this generates a python sdist archive
+    const sdist = zig_python_sdist.createSdistStep(b, .{
+        .name = "zig-zon",
+        .version = zon.version,
+        .description = b.path("README.md"),
+        .build = .{
+            .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" },
+            .{ .src = b.path("src/zig_zon.pyi"), .dest = "src/zig_zon.pyi" },
+        },
+        .compression = .best,
+    });
+
+    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.createVenvInstallTest(
+        b,
+        .{
+            .sdist = sdist.getEmittedArchive(),
+            .unittest_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 cpython = zig_python_sdist.createCPythonModule(b, .{
+        .target = target,
+        .version = zon.version,
+        .optimize = .ReleaseSmall,
+    });
+    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,
+            .imports = &.{
+                .{ .name = "cpython", .module = cpython },
+            },
+        }),
+        .linkage = .dynamic,
+    });
+    const ext_install = zig_python_sdist.installExtLib(b, lib);
+    ext_install_step.dependOn(&ext_install.step);
+
+    ext_install_step.dependOn(&ext_install.step);
+
+    const ext_path = zig_python_sdist.CPython.renameExtLib(b, lib);
+
+    {
+        const ext_tests = ext_path.wf.addCopyFile(b.path("src/test_zig_zon.py"), "test_zig_zon.py");
+        _ = ext_path.wf.addCopyFile(b.path("build.zig.zon"), "build.zig.zon");
+        const test_run = Build.Step.Run.create(b, "unittest");
+        test_run.setCwd(ext_path.wf.getDirectory());
+        test_run.setEnvironmentVariable("PYTHONPATH", ".");
+        test_run.addFileArg(zig_python_sdist.CPython.find(b));
+        if (b.option(bool, "tracetest", "run unittest with tracing") orelse false) {
+            test_run.addArgs(&.{ "-m", "trace", "--trace" });
+        } else {
+            test_run.addArgs(&.{ "-m", "unittest" });
+        }
+        test_run.addDirectoryArg(ext_tests);
+        b.step("test-bdist", "run unittests against the extension").dependOn(&test_run.step);
+    }
+
+    const usf = b.addUpdateSourceFiles();
+    b.step("update-src", "updates the pyi file. needs 'mypy' installed").dependOn(&usf.step);
+
+    {
+        const stubgen_run = Build.Step.Run.create(b, "stubgen");
+        stubgen_run.setCwd(ext_path.wf.getDirectory());
+        stubgen_run.addArgs(&.{
+            "stubgen",
+            "-m",
+            lib.name,
+            "-o",
+        });
+        const stub_dir = stubgen_run.addOutputDirectoryArg("stubgen");
+        stubgen_run.addArg("--search-path");
+        stubgen_run.addDirectoryArg(ext_path.wf.getDirectory());
+        usf.addCopyFileToSource(
+            stub_dir.path(b, b.fmt("{s}.pyi", .{lib.name})),
+            b.fmt("src/{s}.pyi", .{lib.name}),
+        );
+    }
+}

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

@@ -1,12 +1,12 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.2.3",
+    .version = "0.2.5",
     .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .zig_python_sdist = .{
-            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git?ref=0.0.2#3dd2c2eaf62a7007d6c257c357ded7911537621a",
-            .hash = "zig_python_sdist-0.0.2-wjgdOpyrAADPCiUfh4LoKFNZkHstj4a1bIyEuwnNKkcc",
+            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git?ref=0.0.4#79469a3698fe6c11ad0420282e71ff858642a4ac",
+            .hash = "zig_python_sdist-0.0.4-wjgdOukkAQBzC1YymFsy5h5_nZTUlWKUFI9oseCgGkKP",
         },
     },
     .paths = .{
@@ -16,7 +16,5 @@
         "pkg-info.zon",
         "LICENSE",
         "README.md",
-        "setup.py",
-        "pyproject.toml",
     },
 }

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

@@ -14,6 +14,7 @@ with open("setup.zig.json") as fd:
 
 
 def mkversion(v, need_release=False):
+    '''assembles a dict of semantic version to string'''
     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)
@@ -39,15 +40,16 @@ class ZigBuildWheel(bdist_wheel):
         subprocess.check_call(build_cmd)
 
         os.makedirs(self.bdist_dir, exist_ok=True)
-        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 {}/{}'.format(cwd, copy_pattern))
+        copy_pattern = setup_json['build']['copy_pattern']
+        for pattern in copy_pattern:
+            artifacts = glob.glob(pattern)
+            if len(artifacts) == 0:
+                raise Exception(
+                    'no zig artifacts found in {}/{}'.format(cwd, pattern))
 
-        for it in artifacts:
-            shutil.copyfile(it, os.path.join(
-                self.bdist_dir, os.path.basename(it)))
+            for it in artifacts:
+                shutil.copyfile(it, os.path.join(
+                    self.bdist_dir, os.path.basename(it)))
 
         return super().run(*args, **kwargs)
 
@@ -57,6 +59,8 @@ setup(
     version=mkversion(setup_json['version']),
     cmdclass={'bdist_wheel': ZigBuildWheel},
     install_requires=setup_json['install_requires'],
+    entry_points=setup_json['entry_points'],
+    packages=setup_json['build']['packages'],
     setup_requires=[
         "setuptools",
         "wheel",

zig-zon-0.2.5/setup.zig.json

@@ -0,0 +1 @@
+{"name":"zig_zon","version":{"major":0,"minor":2,"patch":5,"pre":null,"build":null},"zig_version":{"major":0,"minor":16,"patch":0,"pre":null,"build":null},"build":{"args":["--fork=zig-pkg/zig_python_sdist-0.0.4","bdist-wheel","-Doptimize=ReleaseSmall"],"requires":[],"packages":[],"copy_pattern":["zig-out/lib/*"]},"install_requires":[],"entry_points":{"console_scripts":[],"gui_scripts":[]}}

zig-zon-0.2.5/src/zig_zon.pyi

@@ -0,0 +1,5 @@
+__version__: dict
+__version_str__: str
+__zig_builtin__: dict
+
+def parse(*args, **kwargs): ...

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

@@ -8,28 +8,54 @@ const cpython = @import("cpython");
 const c = cpython.c;
 const PyObject = c.PyObject;
 
-pub var methods = [_]c.PyMethodDef{
-    c.PyMethodDef{
-        .ml_name = "parse",
-        .ml_meth = @ptrCast(@alignCast(&parse)),
-        .ml_flags = @as(c_int, 1),
-        .ml_doc = "parse a zon literal to a python object",
-    },
-    c.PyMethodDef{},
-};
-
-pub var zigmodule = c.PyModuleDef{
+pub var zigmodule: c.PyModuleDef = .{
     .m_name = "zig_zon",
-    .m_methods = &methods,
+    .m_methods = @constCast(&[_]c.PyMethodDef{
+        .{
+            .ml_name = "parse",
+            .ml_meth = @ptrCast(@alignCast(&parse)),
+            .ml_flags = 1,
+            .ml_doc = "parse a zon literal to a python object",
+        },
+        .{},
+    }),
 };
 
 pub export fn PyInit_zig_zon() [*c]c.PyObject {
     const mod = c.PyModule_Create(&zigmodule);
+
+    {
+        // const annotations = c.PyDict_New();
+        // defer c.Py_DecRef(annotations);
+        // const builtins = c.PyImport_ImportModule("builtins");
+        // defer c.Py_DecRef(builtins);
+
+        // const str_type = c.PyObject_GetAttrString(builtins, "str") orelse PyErrPanic();
+        // defer c.Py_DecRef(str_type);
+
+        // assert(0 <= c.PyDict_SetItemString(annotations, "value", str_type));
+
+        // const parse_ref = c.PyObject_GetAttrString(mod, "parse") orelse PyErrPanic();
+        // defer c.Py_DecRef(parse_ref);
+
+        //TODO: find another way to set annotations, since a builtin function is immutable.
+
+        // if (0 > c.PyObject_SetAttrString(parse_ref, "__annotations__", annotations)) {
+        //     c.PyErr_Print();
+        //     @panic("WTF");
+        // }
+    }
+
     cpython.addVersion(mod);
     cpython.addZigBuiltin(mod);
     return mod;
 }
 
+pub fn PyErrPanic() noreturn {
+    c.PyErr_Print();
+    @panic("Unexpected PyErr!");
+}
+
 pub fn parse(self: [*]PyObject, args: [*]PyObject) callconv(.c) [*c]PyObject {
     _ = self;
     const zon_slice: [:0]u8 = zon_slice: {
@@ -38,7 +64,7 @@ pub fn parse(self: [*]PyObject, args: [*]PyObject) callconv(.c) [*c]PyObject {
         break :zon_slice std.mem.sliceTo(zon_txt, 0);
     };
 
-    var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    var arena_instance = std.heap.ArenaAllocator.init(cpython.py_allocator);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 

zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4/README.md

@@ -0,0 +1,121 @@
+# Zig Python Sdist
+
+this is a toolset to build python source distributions for pypi directly
+using `zig build`. It's inspired by Loris Cro's talk
+[Deinventing the Wheel](https://www.youtube.com/watch?v=HPmefnqirHk).
+
+It allows to add a python distribution to zig packages
+without dealing with python package metadata the traditional way.
+
+You find a full usage example in the [example/](example/) directory.
+
+## `build.zig` api
+
+to generate a python `sdist` archive,
+add the zig package to the `build.zig.zon` file of your existing
+zig >= 0.16.0 project by running:
+
+```
+zig fetch --save git+https://codeberg.org/dasimmet/zig-python-sdist
+```
+
+then, import the dependency and create a source distribution.
+You will have to specify all files or directories (subdirectories are not added
+recursively) necessary to build the extension to add to the sdist archive.
+the `zig-python-sdist` dependency is added automatically for you as well as a `--fork`
+command line argument to `zig build` at wheel build time.
+
+```zig
+const zig_python_sdist = @import("zig_python_sdist");
+
+pub fn build(b: *std.Build) void {
+    const build_ext_step = b.step("bdist-wheel", "build the extension module");
+    {
+        // generate a module from cpython headers
+        const cpython = zig_python_sdist.createCPythonModule(b, .{
+            .target = target,
+            .version = zon.version,
+        });
+
+        // create a shared library, linked against cpython
+        const sdist_dummy = b.addLibrary(.{
+            .name = "sdist_dummy",
+            .linkage = .dynamic,
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("sdist_dummy.zig"),
+                .target = target,
+                .optimize = optimize,
+                .imports = &.{
+                    .{ .name = "cpython", .module = cpython },
+                },
+            }),
+        });
+
+        // install the extension on the "bdist-wheel" top level step
+        const sdist_dummy_install = zig_python_sdist.installExtLib(b, sdist_dummy);
+        build_ext_step.dependOn(&sdist_dummy_install.step);
+    }
+
+    const sdist = zig_python_sdist.createSdistStep(b, .{
+        .name = "python-package-name",
+        .version = @import("build.zig.zon).version,
+        .description = b.path("README.md"),
+
+        .build = .{
+            // the source distribution will build the "bdist-wheel" step on wheel build
+            .args = &.{ 
+                b.fmt("-Doptimize={s}", .{@tagName(optimize)}),
+                build_ext_step.name,
+            },
+        },
+
+        // add all files and directories necessary to build to the source distribution
+        .files = &.{
+            .{ .src = b.path("build.zig.zon"), .dest = "build.zig.zon" },
+            .{ .src = b.path("build.zig"), .dest = "build.zig" },
+            .{ .src = b.path("README.md"), .dest = "README.md" },
+            .{ .src = b.path("LICENSE"), .dest = "LICENSE" },
+        },
+        .directories = &.{
+            .{ .src = b.path("src"), .dest = "src" },
+        },
+
+        // tip: when adding dependency directories, pass a `--fork=<path inside sdist>` to
+        // the build arguments.
+    });
+
+    // the install step only builds the source distribution
+    const sdist_install = sdist.install();
+    b.getInstallStep().dependOn(&sdist_install.step);
+}
+```
+
+## `cpython` zig module
+
+the generated `cpython` module provides a `c` member holding the translated cpython
+headers as well as some utility functions to:
+
+- `addVersion` adds `__version__` and `__version_str__` symbols to your module.
+- `addZigBuiltin` adds a `__zig_builtin__` symbol to your module populated by zig's
+  build information.
+- `wrapMain` wraps a Zig "JuicyMain" function (`fn (std.process.Init) !void`) to be used as an entrypoint for your
+  python module, by populating the `std.process.init` from python's builtin `os` and `sys` modules.
+
+take a look at [example/sdist_dummy.zig](example/sdist_dummy.zig)
+
+## Testing the distribution installation
+
+to test the built source distribution, you can create a `VenvInstallTest` step
+that will:
+
+- create a python virtual environment
+- compile and install your package
+- run python unittest files against the installed package
+- run entrypoints from the installed package to test them
+
+## References
+
+- [Deinventing the Wheel - Loris Cro](https://www.youtube.com/watch?v=HPmefnqirHk)
+- <https://pypi.org/project/setuptools-zig/>
+- <https://pypi.org/project/zig-zon>
+- <https://codeberg.org/dasimmet/python-zig-zon>

zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4/build.zig

@@ -0,0 +1,202 @@
+const std = @import("std");
+const Build = std.Build;
+const LazyPath = Build.LazyPath;
+const zon = @import("build.zig.zon");
+
+// access to the types of the public interface
+pub const CPython = @import("src/build/CPython.zig");
+pub const SDistStep = @import("src/build/SDistStep.zig");
+pub const VenvInstallTest = @import("src/build/VenvInstallTest.zig");
+// public zig build interface
+pub const createSdistStep = createSdist;
+pub const createVenvInstallTest = VenvInstallTest.create;
+pub const createCPythonModule = createModule;
+pub const installExtLib = CPython.installExtLib;
+pub const renameExtLib = CPython.renameExtLib;
+
+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.createModuleInternal(b, b, .{
+        .target = target,
+        .version = zon.version,
+        .optimize = .Debug,
+    });
+
+    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,
+            .imports = &.{
+                .{ .name = "cpython", .module = cpython },
+            },
+        }),
+        .linkage = .dynamic,
+    });
+
+    const install_ext = installExtLib(b, sdist_dummy);
+
+    const build_ext_step = b.step("bdist-wheel", "build the sdist dummy python module");
+    build_ext_step.dependOn(&install_ext.step);
+
+    {
+        const ext_path = CPython.renameExtLib(b, sdist_dummy);
+        const ext_tests = ext_path.wf.addCopyFile(b.path("example/test_ext.py"), "test_ext.py");
+        const test_run = Build.Step.Run.create(b, "unittest");
+        test_run.setCwd(ext_path.wf.getDirectory());
+        test_run.setEnvironmentVariable("PYTHONPATH", ".");
+        test_run.addFileArg(CPython.find(b));
+        test_run.addArgs(&.{ "-m", "unittest" });
+        test_run.addDirectoryArg(ext_tests);
+        b.step("test-bdist", "test the extension against the local python version").dependOn(&test_run.step);
+    }
+
+    {
+        const ext_path = CPython.renameExtLib(b, sdist_dummy);
+        const stubgen_run = Build.Step.Run.create(b, "stubgen");
+        stubgen_run.setCwd(ext_path.wf.getDirectory());
+        stubgen_run.addArgs(&.{
+            "stubgen",
+            "-m",
+            sdist_dummy.name,
+            "-o",
+        });
+        const stub_dir = stubgen_run.addOutputDirectoryArg("stubgen");
+        stubgen_run.addArg("--search-path");
+        stubgen_run.addDirectoryArg(ext_path.wf.getDirectory());
+        const usf = b.addUpdateSourceFiles();
+        usf.addCopyFileToSource(
+            stub_dir.path(b, b.fmt("{s}.pyi", .{sdist_dummy.name})),
+            b.fmt("example/{s}.pyi", .{sdist_dummy.name}),
+        );
+        b.step("stubgen", "generate .pyi from module with mypy stubgen").dependOn(&usf.step);
+    }
+
+    const sdist = SDistStep.createInternal(b, exe, .{
+        .name = "sdist-dummy",
+        .version = zon.version,
+        .description = b.path("README.md"),
+        .build = .{
+            .args = &.{
+                b.fmt("-Doptimize={s}", .{@tagName(optimize)}),
+                build_ext_step.name,
+            },
+            .copy_pattern = &.{
+                "zig-out/lib/*",
+                "example/sdist_dummy.pyi",
+            },
+        },
+        .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" },
+            .{ .src = b.path("example/sdist_dummy.pyi"), .dest = "example/sdist_dummy.pyi" },
+        },
+        .directories = &.{
+            .{ .src = b.path("src/build"), .dest = "src/build" },
+        },
+        .entry_points = .{
+            .console_scripts = &.{
+                "sdist-dummy = sdist_dummy:__main__",
+            },
+        },
+        .install_requires = &.{"ruamel.yaml.clibz"},
+        .zig_version = std.SemanticVersion.parse("0.16.0") catch unreachable,
+        .compression = .best,
+    });
+    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(),
+            .unittest_py = &.{b.path("example/test_ext.py")},
+            .twine_check = true,
+            .entry_points = &.{
+                // TODO: make "some more" one argument on windows
+                &.{ "sdist-dummy", "with", "some more", "args" },
+            },
+            .no_clean = b.option(bool, "pip-no-clean", "cleanup pip temp dirs") orelse false,
+        },
+    );
+    b.step("test-pip-install", "test build and install sdist with pip").dependOn(test_pip_install.step);
+}
+
+fn createModule(b: *Build, options: CPython.LinkOptions) *Build.Module {
+    const this_dep = b.dependencyFromBuildZig(@This(), .{});
+    return CPython.createModuleInternal(b, this_dep.builder, options);
+}
+
+fn createSdist(b: *Build, options: SDistStep.Options) *SDistStep {
+    var opt = options;
+    const this_dep = b.dependencyFromBuildZig(@This(), .{
+        .target = b.graph.host,
+        .optimize = .Debug,
+    });
+    const builder = this_dep.artifact("sdist-builder");
+
+    {
+        var files: std.ArrayList(SDistStep.Content) = .empty;
+        const extra_files: []const SDistStep.Content = &.{
+            .{ .src = this_dep.path("build.zig.zon"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/build.zig.zon" },
+            .{ .src = this_dep.path("build.zig"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/build.zig" },
+            .{ .src = this_dep.path("pkg-info.zon"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/pkg-info.zon" },
+            .{ .src = this_dep.path("README.md"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/README.md" },
+            .{ .src = this_dep.path("LICENSE"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/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 = this_dep.path("src/build"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/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.appendAssumeCapacity("--fork=zig-pkg/zig_python_sdist-" ++ zon.version);
+        args.appendSliceAssumeCapacity(opt.build.args);
+        opt.build.args = args.toOwnedSlice(b.allocator) catch @panic("OOM");
+    }
+
+    return SDistStep.createInternal(b, builder, opt);
+}

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

@@ -1,7 +1,7 @@
 .{
     .name = .zig_python_sdist,
-    .version = "0.0.2",
-    .minimum_zig_version = "0.17.0-dev.947+36069a2a7",
+    .version = "0.0.4",
+    .minimum_zig_version = "0.17.0-dev.1245+efd6f190f",
     .paths = .{
         "build.zig",
         "build.zig.zon",