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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zig-zon
-Version: 0.2.4
+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>

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.4 → zig-zon-0.2.5}/build.zig.zon

@@ -1,12 +1,12 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.2.4",
+    .version = "0.2.5",
     .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .zig_python_sdist = .{
-            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git#b09744edafe683ae6000a96498cc68e86173dbe7",
-            .hash = "zig_python_sdist-0.0.3-wjgdOlzvAADTtFV1n4xTLUwlgCsiLDcmhebfZ7kWM05z",
+            .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.4 → 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)
@@ -40,14 +41,15 @@ class ZigBuildWheel(bdist_wheel):
 
         os.makedirs(self.bdist_dir, exist_ok=True)
         copy_pattern = 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))
+        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)
 
@@ -58,6 +60,7 @@ setup(
     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.4 → 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.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/README.md

@@ -112,3 +112,10 @@ that will:
 - 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.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/build.zig

@@ -12,6 +12,7 @@ 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(.{});
@@ -54,12 +55,52 @@ pub fn build(b: *Build) void {
     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 },
+            .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 = &.{
@@ -67,6 +108,7 @@ pub fn build(b: *Build) void {
             .{ .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" },
@@ -78,6 +120,7 @@ pub fn build(b: *Build) void {
         },
         .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);
@@ -96,7 +139,7 @@ pub fn build(b: *Build) void {
             .no_clean = b.option(bool, "pip-no-clean", "cleanup pip temp dirs") orelse false,
         },
     );
-    b.step("test-pip-install", "").dependOn(test_pip_install.step);
+    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 {

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

@@ -1,6 +1,6 @@
 .{
     .name = .zig_python_sdist,
-    .version = "0.0.3",
+    .version = "0.0.4",
     .minimum_zig_version = "0.17.0-dev.1245+efd6f190f",
     .paths = .{
         "build.zig",

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/CPython.zig

@@ -13,6 +13,7 @@ pub const LinkOptions = struct {
     target: Build.ResolvedTarget,
     optimize: std.builtin.OptimizeMode,
     version: ?[]const u8 = null,
+    header_file: ?LazyPath = null,
     // pass in the python executable for finding headers. use "python" from PATH if omitted.
     python_exe: ?LazyPath = null,
     macros: []const [2][]const u8 = &default_macros,
@@ -29,10 +30,10 @@ pub fn createModuleInternal(b: *Build, sdist_build: *Build, options: LinkOptions
     else
         CPython.find(b);
 
-    const python_inc = generateIncludeDir(b, python);
+    const python_inc = generateIncludeDir(b, sdist_build, python);
 
     const cpython = b.addTranslateC(.{
-        .root_source_file = python_inc.path(b, "zig_python_include.h"),
+        .root_source_file = options.header_file orelse sdist_build.path("src/build/python-translatec.h"),
         .optimize = options.optimize,
         .target = options.target,
     });
@@ -64,18 +65,33 @@ pub fn createModuleInternal(b: *Build, sdist_build: *Build, options: LinkOptions
         .imports = &.{
             .{ .name = "c", .module = cpy_mod },
             .{ .name = "version", .module = version },
+            .{ .name = "pyhexver", .module = b.createModule(.{
+                .root_source_file = python_inc.path(b, "pyhexver.zig"),
+            }) },
         },
     });
 }
 
-pub fn generateIncludeDir(b: *Build, python: LazyPath) LazyPath {
+pub fn generateIncludeDir(b: *Build, sdist_build: *Build, python: LazyPath) LazyPath {
     const extract_link_info = Build.Step.Run.create(b, "python header extraction run");
     extract_link_info.addFileArg(python);
-    const wf = b.addWriteFiles();
-    extract_link_info.addFileArg(wf.add("extract_link_info.py", @embedFile("extract_link_info.py")));
+    extract_link_info.addFileArg(sdist_build.path("src/build/extract_link_info.py"));
     return extract_link_info.addOutputDirectoryArg("pyinclude");
 }
 
+pub fn renameExtLib(b: *Build, lib: *Build.Step.Compile) struct {
+    wf: *Build.Step.WriteFile,
+    ext: LazyPath,
+} {
+    const ext_lib_name = lib_ext_name(b, lib);
+    const wf = b.addWriteFiles();
+    const ext = wf.addCopyFile(lib.getEmittedBin(), ext_lib_name);
+    return .{
+        .wf = wf,
+        .ext = ext,
+    };
+}
+
 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);

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

@@ -0,0 +1,33 @@
+const std = @import("std");
+
+pub const Compression = enum {
+    fastest,
+    default,
+    best,
+    level_1,
+    level_2,
+    level_3,
+    level_4,
+    level_5,
+    level_6,
+    level_7,
+    level_8,
+    level_9,
+
+    pub fn toGzipOptions(self: @This()) std.compress.flate.Compress.Options {
+        return switch (self) {
+            .fastest => .fastest,
+            .default => .default,
+            .best => .best,
+            .level_1 => .level_1,
+            .level_2 => .level_2,
+            .level_3 => .level_3,
+            .level_4 => .level_4,
+            .level_5 => .level_5,
+            .level_6 => .level_6,
+            .level_7 => .level_7,
+            .level_8 => .level_8,
+            .level_9 => .level_9,
+        };
+    }
+};

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/SDistStep.zig

@@ -6,6 +6,7 @@ const LazyPath = Build.LazyPath;
 const LowerDashString = @import("LowerDashString.zig");
 const PkgInfo = @import("pkg_info.zig");
 const SetupJson = @import("setup_json.zig");
+const Compression = @import("Compression.zig").Compression;
 
 const SDistStep = @This();
 
@@ -29,14 +30,7 @@ pub const Options = struct {
     description: ?LazyPath = null,
 
     /// extra configuration for building th python wheel
-    build: struct {
-        /// extra arguments for `zig build` at wheel build time
-        args: []const []const u8 = &.{},
-        /// additional build dependencies for wheel build
-        requires: []const []const u8 = &.{},
-        /// files to copy from zig build to wheel directory. passed glob.glob() after build
-        copy_pattern: ?[]const u8 = null,
-    } = .{},
+    build: SetupJson.Build,
 
     ///additional python packages to depend on at runtime
     install_requires: []const []const u8 = &.{},
@@ -56,6 +50,9 @@ pub const Options = struct {
 
     /// entry points pip should create on install
     entry_points: SetupJson.EntryPoints = .{},
+
+    /// gzip compression level
+    compression: ?Compression = null,
 };
 
 pub fn createInternal(b: *Build, builder: *Build.Step.Compile, options: Options) *SDistStep {
@@ -95,17 +92,17 @@ pub fn createInternal(b: *Build, builder: *Build.Step.Compile, options: Options)
     for (options.directories) |content| {
         self.addDirectory(content);
     }
-    for (options.build.args) |ba| {
-        run.addArg(b.fmt("--build={s}", .{ba}));
-    }
-    for (options.build.requires) |br| {
-        run.addArg(b.fmt("--build-requires={s}", .{br}));
-    }
+
+    run.addArg(b.fmt("--build={f}", .{
+        std.json.fmt(options.build, .{ .whitespace = .minified }),
+    }));
+
     for (options.install_requires) |br| {
         run.addArg(b.fmt("--install-requires={s}", .{br}));
     }
-    if (options.build.copy_pattern) |copy_pattern| {
-        run.addArg(b.fmt("--copy-pattern={s}", .{copy_pattern}));
+
+    if (options.compression) |compression| {
+        run.addArg(b.fmt("--compression={s}", .{@tagName(compression)}));
     }
     if (options.extra_pkg_info.len > 0) {
         const extra_info = std.fmt.allocPrint(b.allocator, "--extra-pkg-info={f}", .{

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/VenvInstallTest.zig

@@ -46,7 +46,7 @@ pub fn create(b: *Build, options: Options) *VenvInstallTest {
     venv_run.addDirectoryArg(venv.getDirectory());
 
     self.python = if (builtin.target.os.tag == .windows)
-        venv.getDirectory().path(b, "Scripts/python")
+        venv.getDirectory().path(b, "Scripts/python.exe")
     else
         venv.getDirectory().path(b, "bin/python");
 

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/extract_link_info.py

@@ -11,7 +11,7 @@ def main():
     syspath = sysconfig.get_paths()
 
     python_h = os.path.join(output_dir, 'Python.h')
-    output_header = os.path.join(output_dir, 'zig_python_include.h')
+    output_header = os.path.join(output_dir, 'pyhexver.zig')
 
     os.makedirs(output_dir, exist_ok=True)
     shutil.copytree(syspath['include'], output_dir, dirs_exist_ok=True)
@@ -26,18 +26,10 @@ def main():
             syspath['include'], output_dir))
 
     output_h_str = '''
-// zig_python_include.h generated by extract_link_info.py
+// pyhexver.zig 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)
+pub const PYHEXVER={};
+'''.format(sources, hex(sys.hexversion))
 
     with open(output_header, 'w') as fd:
         fd.write(output_h_str)

zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4/src/build/python-translatec.h

@@ -0,0 +1,6 @@
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#include "Python.h"
+#include "structmember.h"

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/python.zig

@@ -3,9 +3,21 @@ const builtin = @import("builtin");
 const assert = std.debug.assert;
 pub const c = @import("c");
 pub const version = @embedFile("version");
+pub const PYHEXVER = @import("pyhexver").PYHEXVER;
+
+pub const py_allocator = @import("python_allocator.zig").py_allocator;
+
+/// get the type of 'type'. in the c header this is an opaque type not acessible
+/// by zig
+pub fn getPyType() [*]c.PyObject {
+    const builtins = c.PyImport_ImportModule("builtins");
+    defer c.Py_DecRef(builtins);
+    return c.PyObject.GetAttrString(builtins, "type");
+}
 
 pub const WrapMainOptions = struct {};
 
+/// wraps a zig "Juicy Main" function with a std.process.Init based on pythons args, allocator and environment
 pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.PyObject, [*]c.PyObject) callconv(.c) [*c]c.PyObject {
     _ = options;
 
@@ -52,16 +64,24 @@ pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.
             pub fn main_fn(fn_self: [*]c.PyObject, fn_args: [*]c.PyObject) callconv(.c) [*c]c.PyObject {
                 _ = fn_self;
                 _ = fn_args;
-                var arena: std.heap.ArenaAllocator = .init(std.heap.c_allocator);
-                defer arena.deinit();
-                const alloc = arena.allocator();
+                var arena_impl: std.heap.ArenaAllocator = .init(py_allocator);
+                defer arena_impl.deinit();
+                const arena = arena_impl.allocator();
+
+                var gpa_impl: std.heap.DebugAllocator(.{}) = .{
+                    .backing_allocator = py_allocator,
+                };
+                defer _ = gpa_impl.deinit();
+                const gpa = gpa_impl.allocator();
 
-                var threaded: std.Io.Threaded = .init(std.heap.c_allocator, .{});
+                var threaded: std.Io.Threaded = .init(gpa, .{});
                 defer threaded.deinit();
 
                 const args = args: {
                     const sys = c.PyImport_ImportModule("sys");
+                    defer c.Py_DecRef(sys);
                     const argv = c.PyObject_GetAttrString(sys, "argv");
+                    defer c.Py_DecRef(argv);
                     const arglen = c.PySequence_Length(argv);
 
                     switch (builtin.os.tag) {
@@ -70,54 +90,64 @@ pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.
 
                             for (0..@intCast(arglen)) |arg_i| {
                                 const arg_str = c.PySequence_GetItem(argv, @intCast(arg_i));
+                                defer c.Py_DecRef(arg_str);
                                 const arg_bytes = c.PyUnicode_AsEncodedString(arg_str, "UTF-8", "strict");
+                                defer c.Py_DecRef(arg_bytes);
                                 var arg_ptr: [*c]u8 = undefined;
                                 var arg_len: isize = undefined;
                                 assert(0 <= c.PyBytes_AsStringAndSize(arg_bytes, &arg_ptr, &arg_len));
                                 const arg = arg_ptr[0..@intCast(arg_len) :0];
-                                const arg16 = std.unicode.wtf8ToWtf16LeAllocZ(alloc, arg) catch @panic("OOM");
+                                const arg16 = std.unicode.wtf8ToWtf16LeAllocZ(gpa, arg) catch @panic("OOM");
+                                defer gpa.free(arg16);
 
                                 // check if we need add quoting for windows characters
                                 if (std.mem.findAny(u16, arg16, &.{ ' ', '\t' }) != null) {
-                                    args_list.append(alloc, '"') catch @panic("OOM");
+                                    args_list.append(arena, '"') catch @panic("OOM");
                                     for (arg16) |a| {
                                         switch (a) {
-                                            '"' => args_list.appendSlice(alloc, &.{ '\\', '"' }) catch @panic("OOM"),
-                                            else => args_list.append(alloc, a) catch @panic("OOM"),
+                                            '"' => args_list.appendSlice(arena, &.{ '\\', '"' }) catch @panic("OOM"),
+                                            '\\' => args_list.appendSlice(arena, &.{ '\\', '\\' }) catch @panic("OOM"),
+                                            else => args_list.append(arena, a) catch @panic("OOM"),
                                         }
                                     }
-                                    args_list.appendSlice(alloc, &.{ '"', ' ' }) catch @panic("OOM");
+                                    args_list.appendSlice(arena, &.{ '"', ' ' }) catch @panic("OOM");
                                 } else {
-                                    args_list.appendSlice(alloc, arg16) catch @panic("OOM");
-                                    args_list.append(alloc, ' ') catch @panic("OOM");
+                                    args_list.appendSlice(arena, arg16) catch @panic("OOM");
+                                    args_list.append(arena, ' ') catch @panic("OOM");
                                 }
                             }
 
-                            break :args args_list.toOwnedSlice(alloc) catch @panic("OOM");
+                            break :args args_list.toOwnedSlice(arena) catch @panic("OOM");
                         },
                         else => {
                             var args_list: std.ArrayList([*:0]u8) = .empty;
 
                             for (0..@intCast(arglen)) |arg_i| {
                                 const arg_str = c.PySequence_GetItem(argv, @intCast(arg_i));
+                                defer c.Py_DecRef(arg_str);
                                 const arg_bytes = c.PyUnicode_AsEncodedString(arg_str, "UTF-8", "strict");
+                                defer c.Py_DecRef(arg_bytes);
                                 var arg_ptr: [*c]u8 = undefined;
                                 var arg_len: isize = undefined;
                                 assert(0 <= c.PyBytes_AsStringAndSize(arg_bytes, &arg_ptr, &arg_len));
                                 const arg = arg_ptr[0..@intCast(arg_len) :0];
-                                args_list.append(alloc, arg) catch @panic("OOM");
+                                args_list.append(arena, arg) catch @panic("OOM");
                             }
-                            break :args args_list.toOwnedSlice(alloc) catch @panic("OOM");
+                            break :args args_list.toOwnedSlice(arena) catch @panic("OOM");
                         },
                     }
                 };
 
-                var env: std.process.Environ.Map = .init(alloc);
+                var env: std.process.Environ.Map = .init(gpa);
                 defer env.deinit();
                 {
                     const os = c.PyImport_ImportModule("os");
+                    defer c.Py_DecRef(os);
                     const os_environ = c.PyObject_GetAttrString(os, "environ");
+                    defer c.Py_DecRef(os_environ);
                     const env_dict = c.PyDict_New();
+                    defer c.Py_DecRef(env_dict);
+
                     assert(0 <= c.PyDict_Merge(env_dict, os_environ, 1));
 
                     var dict_key: [*c]c.PyObject = undefined;
@@ -125,12 +155,14 @@ pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.
                     var dict_pos: c.Py_ssize_t = 0;
                     while (c.PyDict_Next(env_dict, &dict_pos, &dict_key, &dict_value) != 0) {
                         const key_bytes = c.PyUnicode_AsEncodedString(dict_key, "UTF-8", "strict");
+                        defer c.Py_DecRef(key_bytes);
                         var key_ptr: [*c]u8 = undefined;
                         var key_len: isize = undefined;
                         assert(0 <= c.PyBytes_AsStringAndSize(key_bytes, &key_ptr, &key_len));
                         const key_str = key_ptr[0..@intCast(key_len) :0];
 
                         const val_bytes = c.PyUnicode_AsEncodedString(dict_value, "UTF-8", "strict");
+                        defer c.Py_DecRef(val_bytes);
                         var val_ptr: [*c]u8 = undefined;
                         var val_len: isize = undefined;
                         assert(0 <= c.PyBytes_AsStringAndSize(val_bytes, &val_ptr, &val_len));
@@ -141,8 +173,8 @@ pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.
                 }
 
                 const init: std.process.Init = .{
-                    .arena = &arena,
-                    .gpa = std.heap.c_allocator,
+                    .arena = &arena_impl,
+                    .gpa = gpa,
                     .io = threaded.io(),
                     .environ_map = &env,
                     .minimal = .{
@@ -175,12 +207,14 @@ pub fn wrapMain(wrap_main: anytype, comptime options: WrapMainOptions) fn ([*]c.
     }
 }
 
+/// adds a __version__ and __version_str__ to the object
 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();
+    defer c.Py_DecRef(version_dict);
     const None = c.Py_BuildValue("");
 
     assert(0 <= c.PyDict_SetItemString(version_dict, "major", c.Py_BuildValue("n", semver.major)));
@@ -188,12 +222,16 @@ pub fn addVersion(mod: [*c]c.PyObject) void {
     assert(0 <= c.PyDict_SetItemString(version_dict, "patch", c.Py_BuildValue("n", semver.patch)));
 
     if (semver.pre) |pre| {
-        assert(0 <= c.PyDict_SetItemString(version_dict, "pre", c.Py_BuildValue("s#", pre.ptr, pre.len)));
+        const pre_str = c.Py_BuildValue("s#", pre.ptr, pre.len);
+        defer c.Py_DecRef(pre_str);
+        assert(0 <= c.PyDict_SetItemString(version_dict, "pre", pre_str));
     } else {
         assert(0 <= c.PyDict_SetItemString(version_dict, "pre", None));
     }
     if (semver.build) |build| {
-        assert(0 <= c.PyDict_SetItemString(version_dict, "build", c.Py_BuildValue("s#", build.ptr, build.len)));
+        const build_str = c.Py_BuildValue("s#", build.ptr, build.len);
+        defer c.Py_DecRef(build_str);
+        assert(0 <= c.PyDict_SetItemString(version_dict, "build", build_str));
     } else {
         assert(0 <= c.PyDict_SetItemString(version_dict, "build", None));
     }
@@ -211,8 +249,10 @@ pub fn addVersion(mod: [*c]c.PyObject) void {
     ));
 }
 
+/// adds a dict of zigs builtin module info to the object
 pub fn addZigBuiltin(mod: [*c]c.PyObject) void {
     const zig_dict = getZigBuitin();
+    defer c.Py_DecRef(zig_dict);
     assert(0 <= c.PyObject_SetAttrString(
         mod,
         "__zig_builtin__",
@@ -221,7 +261,7 @@ pub fn addZigBuiltin(mod: [*c]c.PyObject) void {
 }
 
 pub fn getZigBuitin() *c.PyObject {
-    var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    var arena_instance = std.heap.ArenaAllocator.init(py_allocator);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
     const None = c.Py_BuildValue("");
@@ -229,6 +269,7 @@ pub fn getZigBuitin() *c.PyObject {
     const zig_dict = c.PyDict_New();
     {
         const version_str = c.Py_BuildValue("s#", builtin.zig_version_string.ptr, builtin.zig_version_string.len);
+        defer c.Py_DecRef(version_str);
         assert(0 <= c.PyDict_SetItemString(
             zig_dict,
             "zig_version",
@@ -243,6 +284,7 @@ pub fn getZigBuitin() *c.PyObject {
             .{@tagName(builtin.mode)},
         ) catch @panic("OOM");
         const optmode_str = c.Py_BuildValue("s#", optmode.ptr, optmode.len);
+        defer c.Py_DecRef(optmode_str);
         assert(0 <= c.PyDict_SetItemString(
             zig_dict,
             "optimize",
@@ -257,6 +299,7 @@ pub fn getZigBuitin() *c.PyObject {
             .{@tagName(builtin.zig_backend)},
         ) catch @panic("OOM");
         const backend_str = c.Py_BuildValue("s#", backend.ptr, backend.len);
+        defer c.Py_DecRef(backend_str);
         assert(0 <= c.PyDict_SetItemString(
             zig_dict,
             "backend",
@@ -266,6 +309,7 @@ pub fn getZigBuitin() *c.PyObject {
 
     {
         const target_dict = c.PyDict_New();
+        defer c.Py_DecRef(target_dict);
         assert(0 <= c.PyDict_SetItemString(
             zig_dict,
             "target",
@@ -275,6 +319,7 @@ pub fn getZigBuitin() *c.PyObject {
         {
             const target_triple = builtin.target.zigTriple(arena) catch @panic("OOM");
             const target_triple_str = c.Py_BuildValue("s#", target_triple.ptr, target_triple.len);
+            defer c.Py_DecRef(target_triple_str);
             assert(0 <= c.PyDict_SetItemString(
                 target_dict,
                 "triple",
@@ -284,31 +329,44 @@ pub fn getZigBuitin() *c.PyObject {
 
         {
             const cpu_dict = c.PyDict_New();
+            defer c.Py_DecRef(cpu_dict);
             assert(0 <= c.PyDict_SetItemString(target_dict, "cpu", cpu_dict));
+
             const arch_tag = @tagName(builtin.cpu.arch);
             const arch_str = c.Py_BuildValue("s#", arch_tag.ptr, arch_tag.len);
+            defer c.Py_DecRef(arch_str);
             assert(0 <= c.PyDict_SetItemString(cpu_dict, "arch", arch_str));
+
             const model_str = c.Py_BuildValue("s#", builtin.cpu.model.name.ptr, builtin.cpu.model.name.len);
+            defer c.Py_DecRef(model_str);
             assert(0 <= c.PyDict_SetItemString(cpu_dict, "model", model_str));
+
             const features = c.PyList_New(0);
+            defer c.Py_DecRef(features);
             assert(0 <= c.PyDict_SetItemString(cpu_dict, "features", features));
 
             inline for (comptime builtin.target.cpu.arch.allFeaturesList()) |feature| {
                 if (builtin.target.cpu.has(builtin.target.cpu.arch.family(), @enumFromInt(feature.index))) {
                     const feature_str = c.Py_BuildValue("s#", feature.name.ptr, feature.name.len);
+                    defer c.Py_DecRef(feature_str);
                     assert(c.PyList_Append(features, feature_str) >= 0);
                 }
             }
         }
         {
             const os_dict = c.PyDict_New();
+            defer c.Py_DecRef(os_dict);
             assert(0 <= c.PyDict_SetItemString(target_dict, "os", os_dict));
+
             const os_tag = @tagName(builtin.os.tag);
             const os_str = c.Py_BuildValue("s#", os_tag.ptr, os_tag.len);
+            defer c.Py_DecRef(os_str);
             assert(0 <= c.PyDict_SetItemString(os_dict, "tag", os_str));
+
             switch (builtin.target.os.versionRange()) {
                 .linux => |vrange| {
-                    const android = c.Py_BuildValue("d", vrange.android);
+                    const android = c.Py_BuildValue("I", vrange.android);
+                    defer c.Py_DecRef(android);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "android", android));
 
                     const glibc = std.fmt.allocPrint(
@@ -317,6 +375,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.glibc},
                     ) catch @panic("OOM");
                     const glibc_str = c.Py_BuildValue("s#", glibc.ptr, glibc.len);
+                    defer c.Py_DecRef(glibc_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "glibc_version", glibc_str));
 
                     const min = std.fmt.allocPrint(
@@ -325,6 +384,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.range.min},
                     ) catch @panic("OOM");
                     const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    defer c.Py_DecRef(min_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
 
                     const max = std.fmt.allocPrint(
@@ -333,23 +393,26 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.range.max},
                     ) catch @panic("OOM");
                     const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    defer c.Py_DecRef(max_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
                 },
                 .windows => |vrange| {
                     const min = std.fmt.allocPrint(
                         arena,
-                        "{f}",
-                        .{vrange.min},
+                        "{s}",
+                        .{@tagName(vrange.min)},
                     ) catch @panic("OOM");
                     const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    defer c.Py_DecRef(min_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
 
                     const max = std.fmt.allocPrint(
                         arena,
-                        "{f}",
-                        .{vrange.max},
+                        "{s}",
+                        .{@tagName(vrange.max)},
                     ) catch @panic("OOM");
                     const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    defer c.Py_DecRef(max_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
                 },
                 .semver => |vrange| {
@@ -359,6 +422,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.min},
                     ) catch @panic("OOM");
                     const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    defer c.Py_DecRef(min_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
 
                     const max = std.fmt.allocPrint(
@@ -367,6 +431,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.max},
                     ) catch @panic("OOM");
                     const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    defer c.Py_DecRef(max_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
                 },
                 .hurd => |vrange| {
@@ -376,6 +441,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.glibc},
                     ) catch @panic("OOM");
                     const glibc_str = c.Py_BuildValue("s#", glibc.ptr, glibc.len);
+                    defer c.Py_DecRef(glibc_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "glibc_version", glibc_str));
 
                     const min = std.fmt.allocPrint(
@@ -384,6 +450,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.range.min},
                     ) catch @panic("OOM");
                     const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    defer c.Py_DecRef(min_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
 
                     const max = std.fmt.allocPrint(
@@ -392,6 +459,7 @@ pub fn getZigBuitin() *c.PyObject {
                         .{vrange.range.max},
                     ) catch @panic("OOM");
                     const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    defer c.Py_DecRef(max_str);
                     assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
                 },
                 .none => {},
@@ -401,11 +469,13 @@ pub fn getZigBuitin() *c.PyObject {
         {
             const abi_tag = @tagName(builtin.target.abi);
             const abi_str = c.Py_BuildValue("s#", abi_tag.ptr, abi_tag.len);
+            defer c.Py_DecRef(abi_str);
             assert(0 <= c.PyDict_SetItemString(target_dict, "abi", abi_str));
         }
 
         if (builtin.target.dynamic_linker.get()) |linker| {
             const dynamic_linker = c.Py_BuildValue("s#", linker.ptr, linker.len);
+            defer c.Py_DecRef(dynamic_linker);
             assert(0 <= c.PyDict_SetItemString(target_dict, "dynamic_linker", dynamic_linker));
         } else {
             assert(0 <= c.PyDict_SetItemString(target_dict, "dynamic_linker", None));

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

@@ -0,0 +1,201 @@
+const std = @import("std");
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const builtin = @import("builtin");
+const assert = std.debug.assert;
+pub const c = @import("c");
+
+comptime {
+    if (!builtin.link_libc) {
+        @compileError("C allocator is only available when linking against libc");
+    }
+}
+
+pub const py_allocator: std.mem.Allocator = .{
+    .ptr = undefined,
+    .vtable = &vtable,
+};
+
+const vtable: Allocator.VTable = .{
+    .alloc = alloc,
+    .resize = std.mem.Allocator.noResize,
+    .remap = std.mem.Allocator.noRemap,
+    .free = free,
+};
+
+const have_posix_memalign = switch (builtin.os.tag) {
+    .dragonfly,
+    .netbsd,
+    .freebsd,
+    .illumos,
+    .openbsd,
+    .linux,
+    .driverkit,
+    .ios,
+    .maccatalyst,
+    .macos,
+    .tvos,
+    .visionos,
+    .watchos,
+    .serenity,
+    => true,
+    else => false,
+};
+
+fn allocStrat(need_align: Alignment) union(enum) {
+    raw,
+    posix_memalign: if (have_posix_memalign) void else noreturn,
+    manual_align: if (have_posix_memalign) noreturn else void,
+} {
+    // If `malloc` guarantees `need_align`, always prefer a raw allocation.
+    if (Alignment.compare(need_align, .lte, .of(c.max_align_t))) {
+        return .raw;
+    }
+    // Use `posix_memalign` if available. Otherwise, we must manually align the allocation.
+    return if (have_posix_memalign) .posix_memalign else .manual_align;
+}
+
+/// If `allocStrat(a) == .manual_align`, an allocation looks like this:
+///
+/// unaligned_ptr   hdr_ptr  aligned_ptr
+/// v               v        v
+/// +---------------+--------+--------------+
+/// |    padding    | header | usable bytes |
+/// +---------------+--------+--------------+
+///
+/// * `unaligned_ptr` is the raw return value of `malloc`.
+/// * `aligned_ptr` is computed by aligning `unaligned_ptr` forward; it is what `alloc` returns.
+/// * `hdr_ptr` points to a pointer-sized header directly before the usable space. This header
+///   contains the value `unaligned_ptr`, so that we can pass it to `free` later. This is
+///   necessary because the width of the padding is unknown.
+///
+/// This function accepts `aligned_ptr` and offsets it backwards to return `hdr_ptr`.
+fn manualAlignHeader(aligned_ptr: [*]u8) *[*]u8 {
+    return @ptrCast(@alignCast(aligned_ptr - @sizeOf(usize)));
+}
+
+fn alloc(
+    _: *anyopaque,
+    len: usize,
+    alignment: Alignment,
+    return_address: usize,
+) ?[*]u8 {
+    _ = return_address;
+    assert(len > 0);
+    switch (allocStrat(alignment)) {
+        .raw => {
+            // `std.c.max_align_t` isn't the whole story, because if `len` is smaller than
+            // every C type with alignment `max_align_t`, the allocation can be less-aligned.
+            // The implementation need only guarantee that any type of length `len` would be
+            // suitably aligned.
+            //
+            // For instance, if `len == 8` and `alignment == .@"16"`, then `malloc` may not
+            // fulfil this request, because there is necessarily no C type with 8-byte size
+            // but 16-byte alignment.
+            //
+            // In theory, the resulting rule here would be target-specific, but in practice,
+            // the smallest type with an alignment of `max_align_t` has the same size (it's
+            // usually `c_longdouble`), so we can just extend the allocation size up to the
+            // alignment of `max_align_t` if necessary.
+            const actual_len = @max(len, @alignOf(std.c.max_align_t));
+            const ptr = c.PyMem_Malloc(actual_len) orelse return null;
+            assert(alignment.check(@intFromPtr(ptr)));
+            return @ptrCast(ptr);
+        },
+        .posix_memalign => {
+            // The posix_memalign only accepts alignment values that are a
+            // multiple of the pointer size
+            const effective_alignment = @max(alignment.toByteUnits(), @sizeOf(usize));
+            var aligned_ptr: ?*anyopaque = undefined;
+            if (c.posix_memalign(&aligned_ptr, effective_alignment, len) != 0) {
+                return null;
+            }
+            assert(alignment.check(@intFromPtr(aligned_ptr)));
+            return @ptrCast(aligned_ptr);
+        },
+        .manual_align => {
+            // Overallocate to account for alignment padding and store the original pointer
+            // returned by `malloc` before the aligned address.
+            const padded_len = len + @sizeOf(usize) + alignment.toByteUnits() - 1;
+            const unaligned_ptr: [*]u8 = @ptrCast(c.PyMem_Malloc(padded_len) orelse return null);
+            const unaligned_addr = @intFromPtr(unaligned_ptr);
+            const aligned_addr = alignment.forward(unaligned_addr + @sizeOf(usize));
+            const aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr);
+            manualAlignHeader(aligned_ptr).* = unaligned_ptr;
+            return aligned_ptr;
+        },
+    }
+}
+
+fn resize(
+    _: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) bool {
+    _ = return_address;
+    assert(new_len > 0);
+    if (new_len <= memory.len) {
+        return true; // in-place shrink always works
+    }
+    const mallocSize = func: {
+        if (@TypeOf(std.c.malloc_size) != void) break :func std.c.malloc_size;
+        if (@TypeOf(std.c.malloc_usable_size) != void) break :func std.c.malloc_usable_size;
+        if (@TypeOf(std.c._msize) != void) break :func std.c._msize;
+        return false; // we don't know how much space is actually available
+    };
+    const usable_len: usize = switch (allocStrat(alignment)) {
+        .raw, .posix_memalign => mallocSize(memory.ptr),
+        .manual_align => usable_len: {
+            const unaligned_ptr = manualAlignHeader(memory.ptr).*;
+            const full_len = mallocSize(unaligned_ptr);
+            const padding = @intFromPtr(memory.ptr) - @intFromPtr(unaligned_ptr);
+            break :usable_len full_len - padding;
+        },
+    };
+    return new_len <= usable_len;
+}
+
+fn remap(
+    ctx: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) ?[*]u8 {
+    assert(new_len > 0);
+    // Prefer resizing in-place if possible, since `realloc` could be expensive even if legal.
+    if (resize(ctx, memory, alignment, new_len, return_address)) {
+        return memory.ptr;
+    }
+    switch (allocStrat(alignment)) {
+        .raw => {
+            // `malloc` and friends guarantee the required alignment, so we can try `realloc`.
+            // C only needs to respect `max_align_t` up to the allocation size due to object
+            // alignment rules. If necessary, extend the allocation size.
+            const actual_len = @max(new_len, @alignOf(std.c.max_align_t));
+            const new_ptr = c.PyMem_Realloc(memory.ptr, actual_len) orelse return null;
+            assert(alignment.check(@intFromPtr(new_ptr)));
+            return @ptrCast(new_ptr);
+        },
+        .posix_memalign, .manual_align => {
+            // `realloc` would potentially return a new allocation which does not respect
+            // the original alignment, so we can't do anything more.
+            return null;
+        },
+    }
+}
+
+fn free(
+    _: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    return_address: usize,
+) void {
+    _ = return_address;
+    switch (allocStrat(alignment)) {
+        .raw, .posix_memalign => c.PyMem_Free(memory.ptr),
+        .manual_align => c.PyMem_Free(manualAlignHeader(memory.ptr).*),
+    }
+}

{zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3 → zig-zon-0.2.5/zig-pkg/zig_python_sdist-0.0.4}/src/build/setup_json.zig

@@ -3,14 +3,22 @@ const std = @import("std");
 name: []const u8,
 version: std.SemanticVersion,
 zig_version: std.SemanticVersion,
-build: struct {
+build: Build = .{},
+install_requires: []const []const u8 = &.{},
+entry_points: EntryPoints = .{},
+
+pub const Build = struct {
     args: []const []const u8 = &.{},
+    // extra build dependencies
     requires: []const []const u8 = &.{},
+    // python packages to include
+    packages: []const []const u8 = &.{},
     // pattern of files to copy to bdist after zig build
-    copy_pattern: []const u8 = "zig-out/lib/*",
-} = .{},
-install_requires: []const []const u8 = &.{},
-entry_points: EntryPoints = .{},
+    // defaults to "zig-out/lib/*"
+    copy_pattern: []const []const u8 = &.{
+        "zig-out/lib/*",
+    },
+};
 
 pub const EntryPoints = struct {
     console_scripts: []const []const u8 = &.{},

zig-zon-0.2.4/build.zig

@@ -1,75 +0,0 @@
-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");
-
-    // 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" },
-        },
-    });
-
-    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);
-    }
-}

zig-zon-0.2.4/setup.zig.json

@@ -1 +0,0 @@
-{"name":"zig_zon","version":{"major":0,"minor":2,"patch":4,"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.3","bdist-wheel","-Doptimize=ReleaseSmall"],"requires":[],"copy_pattern":"zig-out/lib/*"},"install_requires":[],"entry_points":{"console_scripts":[],"gui_scripts":[]}}