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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zig-zon
-Version: 0.2.3
+Version: 0.2.4
 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.3 → zig-zon-0.2.4}/build.zig

@@ -11,7 +11,7 @@ pub fn build(b: *Build) void {
     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, .{
+    const sdist = zig_python_sdist.createSdistStep(b, .{
         .name = "zig-zon",
         .version = zon.version,
         .description = b.path("README.md"),
@@ -39,11 +39,11 @@ pub fn build(b: *Build) void {
 
     // we can use a python virtual environment inside
     // the zig cache to test pip installation
-    const test_pip_install = zig_python_sdist.VenvInstallTest.create(
+    const test_pip_install = zig_python_sdist.createVenvInstallTest(
         b,
         .{
             .sdist = sdist.getEmittedArchive(),
-            .test_py = b.path("src/test_zig_zon.py"),
+            .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,
         },
@@ -51,20 +51,23 @@ pub fn build(b: *Build) void {
     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,
         });
-        zig_python_sdist.linkCPython(b, .{
-            .lib = lib,
-            .version = zon.version,
-            .optimize = .ReleaseSmall,
-        });
         const ext_install = zig_python_sdist.installExtLib(b, lib);
 
         ext_install_step.dependOn(&ext_install.step);

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

@@ -1,12 +1,12 @@
 .{
     .name = .python_zig_zon,
     .fingerprint = 0x3d332656a3644fc9,
-    .version = "0.2.3",
+    .version = "0.2.4",
     .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#b09744edafe683ae6000a96498cc68e86173dbe7",
+            .hash = "zig_python_sdist-0.0.3-wjgdOlzvAADTtFV1n4xTLUwlgCsiLDcmhebfZ7kWM05z",
         },
     },
     .paths = .{

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

@@ -39,7 +39,7 @@ 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'])
+        copy_pattern = setup_json['build']['copy_pattern']
         artifacts = glob.glob(copy_pattern)
         if len(artifacts) == 0:
             raise Exception(
@@ -57,6 +57,7 @@ setup(
     version=mkversion(setup_json['version']),
     cmdclass={'bdist_wheel': ZigBuildWheel},
     install_requires=setup_json['install_requires'],
+    entry_points=setup_json['entry_points'],
     setup_requires=[
         "setuptools",
         "wheel",

zig-zon-0.2.4/setup.zig.json

@@ -0,0 +1 @@
+{"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":[]}}

zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3/README.md

@@ -0,0 +1,114 @@
+# 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

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

@@ -3,9 +3,15 @@ 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 VenvInstallTest = @import("src/build/VenvInstallTest.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 fn build(b: *Build) void {
     const target = b.standardTargetOptions(.{});
@@ -24,32 +30,36 @@ pub fn build(b: *Build) void {
 
     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,
     });
 
-    linkCPython(b, .{
-        .lib = sdist_dummy,
-        .version = zon.version,
-    });
     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 sdist = SDistStep.createInternal(b, .{
-        .sdist_builder = exe,
-        .name = "zig-python-sdist-dummy",
+    const sdist = SDistStep.createInternal(b, exe, .{
+        .name = "sdist-dummy",
         .version = zon.version,
         .description = b.path("README.md"),
         .build = .{
-            .args = &.{ build_ext_step.name, b.fmt("-Doptimize={s}", .{@tagName(optimize)}) },
+            .args = &.{ b.fmt("-Doptimize={s}", .{@tagName(optimize)}), build_ext_step.name },
         },
         .extra_pkg_info = @import("pkg-info.zon"),
         .files = &.{
@@ -59,9 +69,13 @@ pub fn build(b: *Build) void {
             .{ .src = b.path("example/sdist_dummy.zig"), .dest = "example/sdist_dummy.zig" },
         },
         .directories = &.{
-            .{ .src = b.path("src"), .dest = "src" },
             .{ .src = b.path("src/build"), .dest = "src/build" },
         },
+        .entry_points = .{
+            .console_scripts = &.{
+                "sdist-dummy = sdist_dummy:__main__",
+            },
+        },
         .install_requires = &.{"ruamel.yaml.clibz"},
         .zig_version = std.SemanticVersion.parse("0.16.0") catch unreachable,
     });
@@ -73,33 +87,39 @@ pub fn build(b: *Build) void {
         b,
         .{
             .sdist = sdist.getEmittedArchive(),
-            .test_py = b.path("example/test_ext.py"),
+            .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", "").dependOn(test_pip_install.step);
 }
 
-pub const linkCPython = CPython.link;
-pub const installExtLib = CPython.installExtLib;
+fn createModule(b: *Build, options: CPython.LinkOptions) *Build.Module {
+    const this_dep = b.dependencyFromBuildZig(@This(), .{});
+    return CPython.createModuleInternal(b, this_dep.builder, options);
+}
 
-pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
+fn createSdist(b: *Build, options: SDistStep.Options) *SDistStep {
     var opt = options;
-    const sdist = b.dependencyFromBuildZig(@This(), .{
+    const this_dep = b.dependencyFromBuildZig(@This(), .{
         .target = b.graph.host,
-        .optimize = .ReleaseFast,
+        .optimize = .Debug,
     });
-    opt.sdist_builder = opt.sdist_builder orelse sdist.artifact("sdist-builder");
+    const builder = this_dep.artifact("sdist-builder");
 
     {
         var files: std.ArrayList(SDistStep.Content) = .empty;
         const extra_files: []const SDistStep.Content = &.{
-            .{ .src = sdist.path("build.zig.zon"), .dest = "zig-pkg/zig_python_sdist/build.zig.zon" },
-            .{ .src = sdist.path("build.zig"), .dest = "zig-pkg/zig_python_sdist/build.zig" },
-            .{ .src = sdist.path("pkg-info.zon"), .dest = "zig-pkg/zig_python_sdist/pkg-info.zon" },
-            .{ .src = sdist.path("README.md"), .dest = "zig-pkg/zig_python_sdist/README.md" },
-            .{ .src = sdist.path("LICENSE"), .dest = "zig-pkg/zig_python_sdist/LICENSE" },
+            .{ .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,
@@ -113,7 +133,7 @@ pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
     {
         var dirs: std.ArrayList(SDistStep.Content) = .empty;
         const extra_dirs: []const SDistStep.Content = &.{
-            .{ .src = sdist.path("src/build"), .dest = "zig-pkg/zig_python_sdist/src/build" },
+            .{ .src = this_dep.path("src/build"), .dest = "zig-pkg/zig_python_sdist-" ++ zon.version ++ "/src/build" },
         };
         dirs.ensureTotalCapacity(
             b.allocator,
@@ -130,10 +150,10 @@ pub fn create(b: *Build, options: SDistStep.Options) *SDistStep {
             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);
-        args.appendAssumeCapacity("--fork=zig-pkg/zig_python_sdist");
         opt.build.args = args.toOwnedSlice(b.allocator) catch @panic("OOM");
     }
 
-    return SDistStep.createInternal(b, opt);
+    return SDistStep.createInternal(b, builder, opt);
 }

{zig-zon-0.2.3/zig-pkg/zig_python_sdist → zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3}/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.3",
+    .minimum_zig_version = "0.17.0-dev.1245+efd6f190f",
     .paths = .{
         "build.zig",
         "build.zig.zon",

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

@@ -1,101 +1,76 @@
+//! a module for building cpython extension libraries,
+//! linking them with system python headers and libs
+
 const std = @import("std");
 const builtin = @import("builtin");
 const Build = std.Build;
 const LazyPath = Build.LazyPath;
 const mem = std.mem;
 
-/// a module for building cpython extension libraries,
-/// linking them with system python headers and libs
 pub const CPython = @This();
 
-exe: LazyPath,
-
-pub fn find(b: *Build) *CPython {
-    const self = b.allocator.create(CPython) catch @panic("OOM");
-    self.* = .{
-        .exe = findProgramCompat(b, &.{
-            "python",
-            "python3",
-        }) orelse {
-            const err_wf = b.addWriteFiles();
-            const err_step = b.addFail("finding python failed. please provide a path to the exe using -Dpython=");
-            err_wf.step.dependOn(&err_step.step);
-            self.* = .{ .exe = err_wf.getDirectory() };
-            return self;
-        },
-    };
-    return self;
-}
-
 pub const LinkOptions = struct {
-    /// library to link against libpython
-    lib: *std.Build.Step.Compile,
+    target: Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
     version: ?[]const u8 = null,
+    // pass in the python executable for finding headers. use "python" from PATH if omitted.
     python_exe: ?LazyPath = null,
-    /// optimize mode for the c module. will fall back to lib's optimize mode.
-    optimize: ?std.builtin.OptimizeMode = null,
     macros: []const [2][]const u8 = &default_macros,
     pub const default_macros = .{
         .{ "Py_LIMITED_API", "0x03060500" }, // use the limited api from 3.6.5
     };
 };
 
-pub fn link(b: *Build, options: LinkOptions) void {
-    const self: *const CPython = if (options.python_exe) |python_exe|
-        &.{ .exe = python_exe }
+// generate a module linked against the python library headers found using
+// a cpython runtime
+pub fn createModuleInternal(b: *Build, sdist_build: *Build, options: LinkOptions) *Build.Module {
+    const python = if (options.python_exe) |python_exe|
+        python_exe
     else
         CPython.find(b);
 
-    const target = Build.ResolvedTarget{
-        .query = .{},
-        .result = options.lib.rootModuleTarget(),
-    };
-
-    const python_inc = self.generateIncludeDir(b);
+    const python_inc = generateIncludeDir(b, python);
 
     const cpython = b.addTranslateC(.{
         .root_source_file = python_inc.path(b, "zig_python_include.h"),
-        .optimize = options.optimize orelse options.lib.root_module.optimize orelse .ReleaseSafe,
-        .target = target,
+        .optimize = options.optimize,
+        .target = options.target,
     });
     cpython.addIncludePath(python_inc);
 
-    const wf = b.addWriteFiles();
+    for (options.macros) |macro| {
+        cpython.defineCMacro(macro[0], macro[1]);
+    }
+    const cpy_mod = cpython.createModule();
 
-    const pymod = b.createModule(.{
-        .root_source_file = wf.add("python.zig", @embedFile("python.zig")),
-        .imports = &.{
-            .{ .name = "c", .module = cpython.createModule() },
-        },
-    });
+    const wf = b.addWriteFiles();
 
-    if (options.version) |version| {
-        pymod.addImport("version", b.createModule(.{
+    const version = if (options.version) |version|
+        b.createModule(.{
             .root_source_file = wf.add("version.txt", version),
-        }));
-    } else {
-        pymod.addImport("version", b.createModule(.{
+        })
+    else
+        b.createModule(.{
             .root_source_file = wf.add("version.txt", "version not provided at configure time!"),
-        }));
-    }
+        });
 
-    for (options.macros) |macro| {
-        cpython.defineCMacro(macro[0], macro[1]);
+    if (options.target.result.os.tag == .windows) {
+        cpy_mod.addLibraryPath(python_inc);
+        cpy_mod.linkSystemLibrary("python", .{});
     }
 
-    if (target.result.os.tag == .windows) {
-        options.lib.root_module.addLibraryPath(python_inc);
-        options.lib.root_module.linkSystemLibrary("python", .{});
-    }
-    options.lib.root_module.addImport(
-        "cpython",
-        pymod,
-    );
+    return b.createModule(.{
+        .root_source_file = sdist_build.path("src/build/python.zig"),
+        .imports = &.{
+            .{ .name = "c", .module = cpy_mod },
+            .{ .name = "version", .module = version },
+        },
+    });
 }
 
-pub fn generateIncludeDir(self: CPython, b: *Build) LazyPath {
+pub fn generateIncludeDir(b: *Build, python: LazyPath) LazyPath {
     const extract_link_info = Build.Step.Run.create(b, "python header extraction run");
-    extract_link_info.addFileArg(self.exe);
+    extract_link_info.addFileArg(python);
     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");
@@ -114,6 +89,18 @@ pub fn lib_ext_name(b: *Build, lib: *Build.Step.Compile) []const u8 {
         b.fmt("{s}.so", .{lib.name});
 }
 
+pub fn find(b: *Build) LazyPath {
+    return 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);
+        return err_wf.getDirectory();
+    };
+}
+
 // compat for 0.16.0 and 0.17.0
 pub fn findProgramCompat(b: *std.Build, names: []const []const u8) ?LazyPath {
     if (comptime (@import("builtin").zig_version.order(std.SemanticVersion.parse("0.16.0") catch unreachable) == .gt)) {

zig-zon-0.2.4/zig-pkg/zig_python_sdist-0.0.3/src/build/LowerDashString.zig

@@ -0,0 +1,20 @@
+//! replaces dashes with lower dashes
+const LowerDashString = @This();
+
+const std = @import("std");
+str: []const u8,
+
+/// replaces dashes with lower dashes
+pub fn fmt(str: []const u8) LowerDashString {
+    return .{ .str = str };
+}
+
+pub fn format(self: LowerDashString, w: *std.Io.Writer) !void {
+    var rest = self.str;
+    while (std.mem.findScalar(u8, rest, '-')) |idx| {
+        try w.writeAll(rest[0..idx]);
+        try w.writeByte('_');
+        rest = rest[idx + 1 ..];
+    }
+    try w.writeAll(rest);
+}