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

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

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

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

@@ -2,14 +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 ext_install_step = b.step("bdist-wheel", "build python extension module");
 
     // this generates a python sdist archive
     const sdist = zig_python_sdist.create(b, .{
@@ -17,7 +16,10 @@ 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)}) },
+            .args = &.{
+                ext_install_step.name,
+                b.fmt("-Doptimize={s}", .{@tagName(optimize)}),
+            },
         },
         .extra_pkg_info = @import("pkg-info.zon"),
         .files = &.{
@@ -49,8 +51,6 @@ pub fn build(b: *Build) void {
     b.step("test-pip-install", "").dependOn(test_pip_install.step);
 
     {
-        const cpython = zig_python_sdist.CPython.find(b);
-
         const lib = b.addLibrary(.{
             .name = "zig_zon",
             .root_module = b.addModule("zig_zon", .{
@@ -60,12 +60,12 @@ pub fn build(b: *Build) void {
             }),
             .linkage = .dynamic,
         });
-        cpython.link(b, .{
+        zig_python_sdist.linkCPython(b, .{
             .lib = lib,
             .version = zon.version,
             .optimize = .ReleaseSmall,
         });
-        const ext_install = zig_python_sdist.CPython.installExtLib(b, lib);
+        const ext_install = zig_python_sdist.installExtLib(b, lib);
 
         ext_install_step.dependOn(&ext_install.step);
     }

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

@@ -1,12 +1,12 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.2.2",
+    .version = "0.2.3",
     .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .zig_python_sdist = .{
-            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git#d5bd94633cf5923342108c824f61b377a2a8c492",
-            .hash = "zig_python_sdist-0.0.1-wjgdOsiNAAC2GtJiAx3dGIloYzgt1_sojmm62pPPalAS",
+            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git?ref=0.0.2#3dd2c2eaf62a7007d6c257c357ded7911537621a",
+            .hash = "zig_python_sdist-0.0.2-wjgdOpyrAADPCiUfh4LoKFNZkHstj4a1bIyEuwnNKkcc",
         },
     },
     .paths = .{

{zig-zon-0.2.2 → zig-zon-0.2.3}/pkg-info.zon

@@ -8,4 +8,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.2 → 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.2 → 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,19 +53,21 @@ 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;
 
@@ -115,8 +120,8 @@ fn parseZonAst(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.Py
             const name_token = tree.firstToken(node);
             const enum_name = tree.tokenSlice(name_token + 1);
             if (std.mem.startsWith(u8, enum_name, "@")) {
-                std.debug.assert(std.mem.startsWith(u8, enum_name, "@\""));
-                std.debug.assert(std.mem.endsWith(u8, enum_name, "\""));
+                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],
@@ -242,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.2 → 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,7 +49,7 @@ pub fn build(b: *Build) void {
         .version = zon.version,
         .description = b.path("README.md"),
         .build = .{
-            .args = &.{build_ext_step.name},
+            .args = &.{ build_ext_step.name, b.fmt("-Doptimize={s}", .{@tagName(optimize)}) },
         },
         .extra_pkg_info = @import("pkg-info.zon"),
         .files = &.{
@@ -63,15 +62,12 @@ pub fn build(b: *Build) void {
             .{ .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,
@@ -85,11 +81,14 @@ pub fn build(b: *Build) void {
     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");
 

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

@@ -1,6 +1,6 @@
 .{
     .name = .zig_python_sdist,
-    .version = "0.0.1",
+    .version = "0.0.2",
     .minimum_zig_version = "0.17.0-dev.947+36069a2a7",
     .paths = .{
         "build.zig",

{zig-zon-0.2.2 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/src/build/CPython.zig

@@ -1,43 +1,27 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const Build = std.Build;
-const fs = std.fs;
+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: Build.LazyPath,
-
-/// adds a `python` option to the build. if not provided, tries to find `python` in PATH
-pub fn findAddOption(b: *Build) *CPython {
-    if (b.option(
-        Build.LazyPath,
-        "python",
-        "path to the cpython interpreter executable",
-    )) |opt| {
-        const self = b.allocator.create(CPython) catch @panic("OOM");
-        self.* = .{
-            .exe = opt,
-        };
-        return self;
-    } else return find(b);
-}
+exe: LazyPath,
 
 pub fn find(b: *Build) *CPython {
     const self = b.allocator.create(CPython) catch @panic("OOM");
-    const exe_path = findProgramCompat(b, &.{
-        "python",
-        "python3",
-    }) orelse {
-        const err_wf = b.addWriteFiles();
-        const err_step = b.addFail("finding python failed. please provide a path to the exe using -Dpython=");
-        err_wf.step.dependOn(&err_step.step);
-        self.* = .{ .exe = err_wf.getDirectory() };
-        return self;
-    };
     self.* = .{
-        .exe = .{
-            .cwd_relative = exe_path,
+        .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;
@@ -47,6 +31,7 @@ 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,
@@ -55,20 +40,12 @@ pub const LinkOptions = struct {
     };
 };
 
-pub fn generateIncludeDir(self: CPython, b: *Build) Build.LazyPath {
-    const extract_link_info = Build.Step.Run.create(b, "python header extraction run");
-    extract_link_info.addFileArg(self.exe);
-    const wf = b.addWriteFiles();
-    extract_link_info.addFileArg(wf.add("extract_link_info.py", @embedFile("extract_link_info.py")));
-    return extract_link_info.addOutputDirectoryArg("include");
-}
-
-pub fn installExtLib(b: *Build, lib: *Build.Step.Compile) *Build.Step.InstallFile {
-    const ext_lib_name = lib_ext_name(b, lib);
-    return b.addInstallLibFile(lib.getEmittedBin(), ext_lib_name);
-}
+pub fn link(b: *Build, options: LinkOptions) void {
+    const self: *const CPython = if (options.python_exe) |python_exe|
+        &.{ .exe = python_exe }
+    else
+        CPython.find(b);
 
-pub fn link(self: CPython, b: *Build, options: LinkOptions) void {
     const target = Build.ResolvedTarget{
         .query = .{},
         .result = options.lib.rootModuleTarget(),
@@ -116,6 +93,19 @@ pub fn link(self: CPython, b: *Build, options: LinkOptions) void {
     );
 }
 
+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)
@@ -125,9 +115,11 @@ pub fn lib_ext_name(b: *Build, lib: *Build.Step.Compile) []const u8 {
 }
 
 // compat for 0.16.0 and 0.17.0
-pub fn findProgramCompat(b: *std.Build, names: []const []const u8) ?[]const u8 {
+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.findProgram(.{ .names = names });
+        return b.findProgramLazy(.{ .names = names });
     }
-    return b.findProgram(names, &.{}) catch null;
+    return .{
+        .cwd_relative = b.findProgram(names, &.{}) catch return null,
+    };
 }

{zig-zon-0.2.2 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/src/build/SDistStep.zig

@@ -16,15 +16,22 @@ pub const Content = struct {
 };
 
 pub const Options = struct {
+    /// name of the python package
     name: []const u8,
     version: []const u8,
+    /// description file. will be added to PKG-INFO
     description: ?LazyPath = null,
-    files: []const Content = &.{},
     build: struct {
+        /// extra arguments for `zig build` at wheel build time
         args: []const []const u8 = &.{},
+        /// additional build requirements for wheel build
         requires: []const []const u8 = &.{},
+        copy_pattern: ?[]const u8 = null,
     } = .{},
+    install_requires: []const []const u8 = &.{},
+    /// extra headers added to PKG-INFO
     extra_pkg_info: []const PkgInfo.Header = &.{},
+    files: []const Content = &.{},
     directories: []const Content = &.{},
     sdist_builder: ?*Build.Step.Compile = null,
     // the version of the ziglang python package to depend on.
@@ -53,7 +60,7 @@ pub fn createInternal(b: *Build, options: Options) *SDistStep {
     if (zig_version.build != null or zig_version.pre != null) {
         std.log.warn("the python ziglang package is only published for releases.", .{});
         std.log.warn("the resulting sdist might not be installable!", .{});
-        std.log.warn("set .zig_version for your sdist to a release explicitly", .{});
+        std.log.warn("you can set .zig_version for your sdist to a release explicitly and test the pip build against it.", .{});
     }
 
     run.addArg(b.fmt("--zig-version={f}", .{zig_version}));
@@ -73,6 +80,12 @@ pub fn createInternal(b: *Build, options: Options) *SDistStep {
     for (options.build.requires) |br| {
         run.addArg(b.fmt("--build-requires={s}", .{br}));
     }
+    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.extra_pkg_info.len > 0) {
         const extra_info = std.fmt.allocPrint(b.allocator, "--extra-pkg-info={f}", .{
             std.json.fmt(options.extra_pkg_info, .{ .whitespace = .minified }),
@@ -91,3 +104,12 @@ pub fn createInternal(b: *Build, options: Options) *SDistStep {
 pub fn getEmittedArchive(self: *SDistStep) LazyPath {
     return self.archive;
 }
+
+pub fn install(self: *SDistStep) *Build.Step.InstallFile {
+    const b = self.builder.step.owner;
+    return b.addInstallFileWithDir(
+        self.getEmittedArchive(),
+        .{ .custom = "src" },
+        self.basename,
+    );
+}

{zig-zon-0.2.2 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/src/build/VenvInstallTest.zig

@@ -31,11 +31,12 @@ pub fn create(b: *Build, options: Options) *VenvInstallTest {
         venv_run.addFileArg(python);
     } else {
         if (CPython.findProgramCompat(b, &.{ "python", "python3" })) |python| {
-            venv_run.addArg(python);
+            venv_run.addFileArg(python);
         } else {
             venv_run.step.dependOn(&b.addFail("system python not found").step);
         }
     }
+
     venv_run.addArgs(&.{ "-m", "venv" });
     venv_run.addDirectoryArg(wf.getDirectory());
     const venv_python = if (builtin.target.os.tag == .windows)
@@ -47,22 +48,21 @@ pub fn create(b: *Build, options: Options) *VenvInstallTest {
     deps_run.addFileArg(venv_python);
     deps_run.step.dependOn(&wf.step);
 
+    deps_run.addArgs(&.{
+        "-m",
+        "pip",
+        "install",
+        "-U",
+    });
+
     if (options.twine_check) {
         deps_run.addArgs(&.{
-            "-m",
-            "pip",
-            "install",
-            "-U",
             "pip",
             "wheel",
             "twine",
         });
     } else {
         deps_run.addArgs(&.{
-            "-m",
-            "pip",
-            "install",
-            "-U",
             "pip",
             "wheel",
         });

{zig-zon-0.2.2 → zig-zon-0.2.3}/zig-pkg/zig_python_sdist/src/build/pkg_info.zig

@@ -30,22 +30,3 @@ pub fn format(self: @This(), w: *std.Io.Writer) !void {
     try w.writeAll("\n");
     try w.writeAll(self.description.items);
 }
-
-// Metadata-Version: 2.4
-// Name: zig-zon
-// Version: 0.1.3
-// Summary: a native cpython extension to parse zig object notation strings
-// Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
-// Maintainer-email: Tobias Simetsreiter <dasimmet@gmail.com>
-// License-Expression: MIT
-// Project-URL: Homepage, https://codeberg.org/dasimmet/python-zig-zon
-// Project-URL: Issues, https://codeberg.org/dasimmet/python-zig-zon/issues
-// Keywords: zig,ziglang,zon,cpython
-// Classifier: Development Status :: 4 - Beta
-// Classifier: Intended Audience :: Developers
-// Classifier: Programming Language :: Python :: 3
-// Classifier: Programming Language :: Python :: 3.9
-// Requires-Python: >=3.9
-// Description-Content-Type: text/markdown
-// License-File: LICENSE
-// Dynamic: license-file

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

@@ -0,0 +1,217 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const assert = std.debug.assert;
+pub const c = @import("c");
+pub const version = @embedFile("version");
+
+pub fn addVersion(mod: [*c]c.PyObject) void {
+    const semver = comptime std.SemanticVersion.parse(version) catch {
+        @compileLog("could not parse version:");
+        @compileError(version);
+    };
+    const version_dict = c.PyDict_New();
+    const None = c.Py_BuildValue("");
+
+    assert(0 <= c.PyDict_SetItemString(version_dict, "major", c.Py_BuildValue("n", semver.major)));
+    assert(0 <= c.PyDict_SetItemString(version_dict, "minor", c.Py_BuildValue("n", semver.minor)));
+    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)));
+    } 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)));
+    } else {
+        assert(0 <= c.PyDict_SetItemString(version_dict, "build", None));
+    }
+    assert(0 <= c.PyObject_SetAttrString(
+        mod,
+        "__version__",
+        version_dict,
+    ));
+
+    const version_str = c.Py_BuildValue("s#", version.ptr, version.len);
+    assert(0 <= c.PyObject_SetAttrString(
+        mod,
+        "__version_str__",
+        version_str,
+    ));
+}
+
+pub fn addZigBuiltin(mod: [*c]c.PyObject) void {
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+
+    const None = c.Py_BuildValue("");
+
+    const zig_dict = c.PyDict_New();
+    assert(0 <= c.PyObject_SetAttrString(
+        mod,
+        "__zig_builtin__",
+        zig_dict,
+    ));
+
+    {
+        const version_str = c.Py_BuildValue("s#", builtin.zig_version_string.ptr, builtin.zig_version_string.len);
+        assert(0 <= c.PyDict_SetItemString(
+            zig_dict,
+            "zig_version",
+            version_str,
+        ));
+    }
+
+    {
+        const optmode = std.fmt.allocPrint(
+            arena,
+            "{s}",
+            .{@tagName(builtin.mode)},
+        ) catch @panic("OOM");
+        const optmode_str = c.Py_BuildValue("s#", optmode.ptr, optmode.len);
+        assert(0 <= c.PyDict_SetItemString(
+            zig_dict,
+            "optimize",
+            optmode_str,
+        ));
+    }
+
+    {
+        const backend = std.fmt.allocPrint(
+            arena,
+            "{s}",
+            .{@tagName(builtin.zig_backend)},
+        ) catch @panic("OOM");
+        const backend_str = c.Py_BuildValue("s#", backend.ptr, backend.len);
+        assert(0 <= c.PyDict_SetItemString(
+            zig_dict,
+            "backend",
+            backend_str,
+        ));
+    }
+
+    {
+        const target_dict = c.PyDict_New();
+        assert(0 <= c.PyDict_SetItemString(
+            zig_dict,
+            "target",
+            target_dict,
+        ));
+
+        {
+            const target_triple = builtin.target.zigTriple(arena) catch @panic("OOM");
+            const target_triple_str = c.Py_BuildValue("s#", target_triple.ptr, target_triple.len);
+            assert(0 <= c.PyDict_SetItemString(
+                target_dict,
+                "triple",
+                target_triple_str,
+            ));
+        }
+
+        {
+            const cpu_dict = c.PyDict_New();
+            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);
+            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);
+            assert(0 <= c.PyDict_SetItemString(cpu_dict, "model", model_str));
+            const features = c.PyList_New(0);
+            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);
+                    assert(c.PyList_Append(features, feature_str) >= 0);
+                }
+            }
+        }
+        {
+            const os_dict = c.PyDict_New();
+            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);
+            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);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "android", android));
+
+                    const glibc = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.glibc},
+                    ) catch @panic("OOM");
+                    const glibc_str = c.Py_BuildValue("s#", glibc.ptr, glibc.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "glibc_version", glibc_str));
+
+                    const min = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.range.min},
+                    ) catch @panic("OOM");
+                    const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
+
+                    const max = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.range.max},
+                    ) catch @panic("OOM");
+                    const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
+                },
+                .windows => |vrange| {
+                    const min = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.min},
+                    ) catch @panic("OOM");
+                    const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
+
+                    const max = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.max},
+                    ) catch @panic("OOM");
+                    const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
+                },
+                .semver => |vrange| {
+                    const min = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.min},
+                    ) catch @panic("OOM");
+                    const min_str = c.Py_BuildValue("s#", min.ptr, min.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "min_version", min_str));
+
+                    const max = std.fmt.allocPrint(
+                        arena,
+                        "{f}",
+                        .{vrange.max},
+                    ) catch @panic("OOM");
+                    const max_str = c.Py_BuildValue("s#", max.ptr, max.len);
+                    assert(0 <= c.PyDict_SetItemString(os_dict, "max_version", max_str));
+                },
+                .hurd => {},
+                .none => {},
+            }
+        }
+
+        {
+            const abi_tag = @tagName(builtin.target.abi);
+            const abi_str = c.Py_BuildValue("s#", abi_tag.ptr, abi_tag.len);
+            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);
+            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.2/setup.zig.json

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

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

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