import-zig 0.13.0__tar.gz

import_zig-0.13.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Felix Graßl.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

import_zig-0.13.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: import_zig
+Version: 0.13.0
+Summary: Compile and import Zig functions at runtime without building a package
+Author: Felix Graßl
+License: MIT
+Project-URL: Homepage, https://github.com/ffelixg/import_zig
+Project-URL: Issues, https://github.com/ffelixg/import_zig/issues
+Keywords: zig,ziglang,import,compile
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ziglang==0.13
+
+# import-zig
+
+    pip install import-zig
+
+This module provides a way to import Zig code directly into Python using a single function call to `import_zig`. Here is an example:
+
+```py
+from import_zig import import_zig
+
+mod = import_zig(source_code = """
+    pub fn Q_rsqrt(number: f32) f32 {
+        const threehalfs: f32 = 1.5;
+        const x2 = number * 0.5;
+        var y = number;
+        var i: i32 = @bitCast(y);
+        i = 0x5f3759df - (i >> 1);
+        y = @bitCast(i);
+        y = y * (threehalfs - (x2 * y * y));
+
+        return y;
+    }
+""")
+
+print(f"1 / sqrt(1.234) = {mod.Q_rsqrt(1.234)}")
+```
+
+The main goal of this module is to make it easy to prototype Zig extensions for Python without having to engage with the Python build system. When building larger Zig extensions it is likely preferable to write your own build process with setuptools or to use a ziggy-pydust template, which provides a comptime abstraction over many aspects of the Python C API. Zig and Zig extensions are still very new though, so things will likely change. Technically you could also use this module as part of a packaging step by calling the `compile_to` function to build the binary and moving it into the packages build folder.
+
+One approach that I expect to stay the same is the comptime wrapping for conversion between Zig and Python types as well as exception handling. This is conveniently packed into the file `py_utils.zig` and could be copy pasted into a new setuptools based project and maybe adjusted.
+
+See the docs of the import_zig function for more details or check out the examples directory.
+
+# File structure
+
+The file structure that will be generated to compile the Zig code looks as follows.
+
+```bash
+project_folder
+├── build.zig
+├── generated.zig
+├── inner
+│   └── import_fns.zig
+├── py_utils.zig
+└── zig_ext.zig
+```
+
+The `inner` directory is where your code lives. When you pass a source code string or file path, it will be written / linked as the `import_fns.zig` file. When you pass a directory path, the directory will be linked as the `inner` directory above, enabling references to other files in the directory path.
+
+The above file structure can be generated with:
+
+```py
+import_zig.prepare("/path/to/project_folder", "module_name")
+```
+
+This enables ZLS support for the Python C API when importing `py_utils` from `import_fns.zig`.
+
+# Type mapping
+
+The conversion is defined in `py_utils.zig` and applied based on the parameter / return types of the exported function. Errors are also forwarded. The solution to passing variable length data back to Python is a bit of a hack: When an exported function specifies `std.mem.Allocator` as a parameter type, then an arena allocator - which gets deallocated after the function call - will be passed into the function. The allocator can then be used to allocate and return new slices for example.
+
+For nested types, the conversion is applied recursively.
+
+| Conversion from Python                  | Zig datatype                      | Conversion to Python                          |
+| --------------------------------------- | --------------------------------- | --------------------------------------------- |
+| int                                     | integer (any size / sign)         | int                                           |
+| float                                   | float (any size)                  | float                                         |
+| -                                       | void                              | None                                          |
+| evaluated like bool()                   | bool                              | bool                                          |
+| sequence                                | array                             | list                                          |
+| sequence                                | non u8 const slice                | list                                          |
+| str                                     | u8 const slice                    | str                                           |
+| dict or sequence                        | struct                            | tuple if struct is a tuple or named tuple     |
+| comparison with None                    | optional                          | null -> None                                  |

import_zig-0.13.0/README.md

@@ -0,0 +1,73 @@
+# import-zig
+
+    pip install import-zig
+
+This module provides a way to import Zig code directly into Python using a single function call to `import_zig`. Here is an example:
+
+```py
+from import_zig import import_zig
+
+mod = import_zig(source_code = """
+    pub fn Q_rsqrt(number: f32) f32 {
+        const threehalfs: f32 = 1.5;
+        const x2 = number * 0.5;
+        var y = number;
+        var i: i32 = @bitCast(y);
+        i = 0x5f3759df - (i >> 1);
+        y = @bitCast(i);
+        y = y * (threehalfs - (x2 * y * y));
+
+        return y;
+    }
+""")
+
+print(f"1 / sqrt(1.234) = {mod.Q_rsqrt(1.234)}")
+```
+
+The main goal of this module is to make it easy to prototype Zig extensions for Python without having to engage with the Python build system. When building larger Zig extensions it is likely preferable to write your own build process with setuptools or to use a ziggy-pydust template, which provides a comptime abstraction over many aspects of the Python C API. Zig and Zig extensions are still very new though, so things will likely change. Technically you could also use this module as part of a packaging step by calling the `compile_to` function to build the binary and moving it into the packages build folder.
+
+One approach that I expect to stay the same is the comptime wrapping for conversion between Zig and Python types as well as exception handling. This is conveniently packed into the file `py_utils.zig` and could be copy pasted into a new setuptools based project and maybe adjusted.
+
+See the docs of the import_zig function for more details or check out the examples directory.
+
+# File structure
+
+The file structure that will be generated to compile the Zig code looks as follows.
+
+```bash
+project_folder
+├── build.zig
+├── generated.zig
+├── inner
+│   └── import_fns.zig
+├── py_utils.zig
+└── zig_ext.zig
+```
+
+The `inner` directory is where your code lives. When you pass a source code string or file path, it will be written / linked as the `import_fns.zig` file. When you pass a directory path, the directory will be linked as the `inner` directory above, enabling references to other files in the directory path.
+
+The above file structure can be generated with:
+
+```py
+import_zig.prepare("/path/to/project_folder", "module_name")
+```
+
+This enables ZLS support for the Python C API when importing `py_utils` from `import_fns.zig`.
+
+# Type mapping
+
+The conversion is defined in `py_utils.zig` and applied based on the parameter / return types of the exported function. Errors are also forwarded. The solution to passing variable length data back to Python is a bit of a hack: When an exported function specifies `std.mem.Allocator` as a parameter type, then an arena allocator - which gets deallocated after the function call - will be passed into the function. The allocator can then be used to allocate and return new slices for example.
+
+For nested types, the conversion is applied recursively.
+
+| Conversion from Python                  | Zig datatype                      | Conversion to Python                          |
+| --------------------------------------- | --------------------------------- | --------------------------------------------- |
+| int                                     | integer (any size / sign)         | int                                           |
+| float                                   | float (any size)                  | float                                         |
+| -                                       | void                              | None                                          |
+| evaluated like bool()                   | bool                              | bool                                          |
+| sequence                                | array                             | list                                          |
+| sequence                                | non u8 const slice                | list                                          |
+| str                                     | u8 const slice                    | str                                           |
+| dict or sequence                        | struct                            | tuple if struct is a tuple or named tuple     |
+| comparison with None                    | optional                          | null -> None                                  |

import_zig-0.13.0/import_zig/__init__.py

@@ -0,0 +1,168 @@
+from pathlib import Path
+from shutil import copyfile, copytree
+from tempfile import TemporaryDirectory
+from importlib import import_module
+import sysconfig
+import sys
+import subprocess
+import random
+import platform
+
+_copy_paths = [
+    Path(__file__).parent / "build.zig",
+    Path(__file__).parent / "py_utils.zig",
+    Path(__file__).parent / "zig_ext.zig",
+]
+
+
+_is_windows = platform.system() == "Windows"
+
+
+def _escape(path: str) -> str:
+    return path.replace("\\", "\\\\")
+
+
+def prepare(path: str | Path, module_name: str, hardlink_only: bool = False):
+    """
+    Link/Create files at path needed to compile the Zig code
+
+    In order to get ZLS support for the Python C API, you can execute this and
+    develop inside the "inner" directory.
+    """
+    path = Path(path)
+    if not path.exists():
+        path.mkdir()
+
+    for src in _copy_paths:
+        tgt = path / src.name
+        if hardlink_only:
+            # Symlinks are buggy on windows
+            (tgt).hardlink_to(src)
+        else:
+            copyfile(src, tgt)
+
+    (path / "inner").mkdir()
+
+    include_dirs = [sysconfig.get_path("include")]
+    lib_paths = [
+        str(Path(sysconfig.get_config_var("installed_base"), "Libs").absolute())
+    ]
+
+    with (path / "generated.zig").open("w", encoding="utf-8") as f:
+        f.write(
+            f"pub const include: [{len(include_dirs)}][]const u8 = .{{\n"
+            + "".join(f'    "{p}",\n' for p in map(_escape, include_dirs))
+            + "};\n"
+            + f"pub const lib: [{len(lib_paths)}][]const u8 = .{{\n"
+            + "".join(f'    "{p}",\n' for p in map(_escape, lib_paths))
+            + "};\n"
+            + f'pub const module_name = "{module_name}";\n'
+        )
+
+
+def compile_to(
+    target_dir: str | Path,
+    module_name: str = "zig_ext",
+    source_code: str | None = None,
+    file: Path | str | None = None,
+    directory: Path | str | None = None,
+):
+    """
+    Same as import_zig, except that the module will not be imported an instead
+    copied into the directory specified by `path_target`.
+
+    Further, `module_name` is not randomized.
+    """
+    if (source_code is not None) + (file is not None) + (directory is not None) != 1:
+        raise Exception(
+            "Exactly one method must be used to specify location of Zig file(s)."
+        )
+
+    with TemporaryDirectory(prefix="import_zig_compile_") as tempdir:
+        temppath = Path(tempdir)
+        prepare(temppath, module_name, hardlink_only=True)
+
+        temppath_inner = temppath / "inner"
+        if directory is not None:
+            temppath_inner.rmdir()
+            if _is_windows:
+                copytree(Path(directory).absolute(), temppath_inner)
+            else:
+                temppath_inner.symlink_to(Path(directory).absolute())
+        elif file is not None:
+            (temppath_inner / "import_fns.zig").hardlink_to(Path(file).absolute())
+        else:
+            assert source_code is not None
+            with (temppath_inner / "import_fns.zig").open("w", encoding="utf-8") as f:
+                f.write(source_code)
+
+        args = [
+            sys.executable,
+            "-m",
+            "ziglang",
+            "build",
+            *(["-Dtarget=x86_64-windows"] if _is_windows else []),
+        ]
+        subprocess.run(args, cwd=tempdir, check=True)
+
+        (binary,) = (
+            p
+            for p in (temppath / "zig-out").glob(f"**/*{'.dll' if _is_windows else ''}")
+            if p.is_file()
+        )
+
+        binary.rename(
+            Path(target_dir) / (module_name + sysconfig.get_config_var("EXT_SUFFIX"))
+        )
+
+
+def import_zig(
+    module_name: str | None = None,
+    source_code: str | None = None,
+    file: Path | str | None = None,
+    directory: Path | str | None = None,
+):
+    """
+    This function takes in Zig code, wraps it in the Python C API, compiles the
+    code and returns the imported binary.
+
+    Assumptions on the code:
+    The Zig source can be specified as a source code string, a file or a directory.
+    If it is specified as a directory, the file containin the functions which get
+    exported to Python must be named `import_fns.zig`, however that file may use
+    any other files present in the directory.
+
+    A function gets exposed to Python if it is marked pub.
+
+    It is possible to use
+    ```
+    const pyu = @import("../py_utils.zig");
+    const py = pyu.py;
+    ```
+    in order to access the Python C API with `py` and utilities with `pyu`. This
+    allows for example raising exceptions or passing Python objects with
+    `*py.PyObject`.
+
+    If module_name is left blank, a random name will be assigned.
+    """
+    if module_name is None:
+        module_name = f"zig_ext_{hex(random.randint(0, 2**128))[2:]}"
+
+    # For some reason the binary can't be deleted on windows, so it will live on
+    # due to ignore_cleanup_errors. Hopefully the OS takes care of it eventually.
+    with TemporaryDirectory(
+        prefix="import_zig_", ignore_cleanup_errors=True
+    ) as tempdir:
+        compile_to(
+            tempdir,
+            source_code=source_code,
+            file=file,
+            directory=directory,
+            module_name=module_name,
+        )
+        sys.path.append(tempdir)
+        try:
+            module = import_module(module_name)
+        finally:
+            sys.path.remove(tempdir)
+        return module

import_zig-0.13.0/import_zig/build.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const generated = @import("generated.zig");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{ .preferred_optimize_mode = .Debug });
+
+    const lib = b.addSharedLibrary(.{
+        .name = "zig_ext",
+        // .root_source_file = b.path("zig_ext_export.zig"),
+        .root_source_file = b.path("zig_ext.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    lib.linkLibC();
+    inline for (generated.include) |path| {
+        lib.addIncludePath(.{ .cwd_relative = path });
+    }
+    inline for (generated.lib) |path| {
+        lib.addLibraryPath(.{ .cwd_relative = path });
+    }
+    if (target.query.os_tag == .windows) {
+        lib.linkSystemLibrary2("python3", .{ .needed = true, .preferred_link_mode = .static });
+    }
+    lib.linker_allow_shlib_undefined = true;
+    b.installArtifact(lib);
+}

import_zig-0.13.0/import_zig/py_utils.zig

@@ -0,0 +1,275 @@
+const std = @import("std");
+pub const py = @cImport({
+    @cDefine("Py_LIMITED_API", "0x030a00f0");
+    @cDefine("PY_SSIZE_T_CLEAN", {});
+    @cInclude("Python.h");
+});
+
+var gpa = std.heap.GeneralPurposeAllocator(.{ .safety = true }){};
+pub const gp_allocator = gpa.allocator();
+
+pub const PyErr = error{PyErr};
+const Exceptions = enum { Exception, NotImplemented, TypeError, ValueError };
+
+pub fn raise(exc: Exceptions, comptime msg: []const u8, args: anytype) PyErr {
+    @setCold(true);
+    const pyexc = switch (exc) {
+        .Exception => py.PyExc_Exception,
+        .NotImplemented => py.PyExc_NotImplementedError,
+        .TypeError => py.PyExc_TypeError,
+        .ValueError => py.PyExc_ValueError,
+    };
+    const formatted = std.fmt.allocPrintZ(gp_allocator, msg, args) catch "Error formatting error message";
+    defer gp_allocator.free(formatted);
+
+    // new in Python 3.12, for older versions we just overwrite exceptions.
+    if (@hasField(py, "PyErr_GetRaisedException")) {
+        const cause = py.PyErr_GetRaisedException();
+        py.PyErr_SetString(pyexc, formatted.ptr);
+        if (cause) |_| {
+            const consequence = py.PyErr_GetRaisedException();
+            py.PyException_SetCause(consequence, cause);
+            py.PyErr_SetRaisedException(consequence);
+        }
+    } else {
+        py.PyErr_SetString(pyexc, formatted.ptr);
+    }
+    return PyErr.PyErr;
+}
+
+fn toPyList(value: anytype) !*py.PyObject {
+    const pylist = py.PyList_New(@intCast(value.len)) orelse return PyErr.PyErr;
+    errdefer py.Py_DECREF(pylist);
+    for (value, 0..) |entry, i_entry| {
+        const py_entry = try zig_to_py(entry);
+        if (py.PyList_SetItem(pylist, @intCast(i_entry), py_entry) == -1) {
+            py.Py_DECREF(py_entry);
+            return PyErr.PyErr;
+        }
+    }
+    return pylist;
+}
+
+var struct_tuple_map = std.StringHashMap(?*py.PyTypeObject).init(gp_allocator);
+
+/// Steals a reference when passed PyObjects
+pub fn zig_to_py(value: anytype) !*py.PyObject {
+    return switch (@typeInfo(@TypeOf(value))) {
+        .Int => |info| if (info.signedness == .signed) py.PyLong_FromLongLong(@as(c_longlong, value)) else py.PyLong_FromUnsignedLongLong(@as(c_ulonglong, value)),
+        .ComptimeInt => if (value < 0) py.PyLong_FromLongLong(@as(c_longlong, value)) else py.PyLong_FromUnsignedLongLong(@as(c_ulonglong, value)),
+        .Void => py.Py_NewRef(py.Py_None()),
+        .Float => py.PyFloat_FromDouble(@floatCast(value)),
+        .ComptimeFloat => py.PyFloat_FromDouble(@floatCast(value)),
+        .Bool => py.PyBool_FromLong(@intFromBool(value)),
+        .Optional => if (value) |v| zig_to_py(v) catch null else py.Py_NewRef(py.Py_None()),
+        .Array => |info| if (info.sentinel) |_|
+            @compileError("Sentinel is not supported")
+        else
+            toPyList(value) catch null,
+        .Pointer => |info| if (info.child == u8 and info.size == .Slice)
+            py.PyUnicode_FromStringAndSize(value.ptr, @intCast(value.len))
+        else if (info.child == py.PyObject and info.size == .One)
+            @as(?*py.PyObject, value)
+        else if (info.size == .Slice)
+            toPyList(value) catch null
+        else
+            unreachable,
+        .Struct => |info| blk: {
+            if (info.is_tuple) {
+                const tuple = py.PyTuple_New(info.fields.len) orelse return PyErr.PyErr;
+                errdefer py.Py_DECREF(tuple);
+                inline for (info.fields, 0..) |field, i_field| {
+                    const py_value = try zig_to_py(@field(value, field.name));
+                    if (py.PyTuple_SetItem(tuple, @intCast(i_field), py_value) == -1) {
+                        py.Py_DECREF(py_value);
+                        return PyErr.PyErr;
+                    }
+                }
+                break :blk tuple;
+            } else {
+                const type_name = @typeName(@TypeOf(value));
+                const tuple_type = struct_tuple_map.get(type_name) orelse blk_tp: {
+                    var fields: [info.fields.len + 1]py.PyStructSequence_Field = undefined;
+                    fields[fields.len - 1] = py.PyStructSequence_Field{ .doc = null, .name = null };
+                    inline for (info.fields, 0..) |field, i_field| {
+                        fields[i_field] = py.PyStructSequence_Field{
+                            .doc = "Zig type for this field is " ++ @typeName(field.type),
+                            .name = field.name,
+                        };
+                    }
+
+                    var desc: py.PyStructSequence_Desc = .{
+                        .doc = "Generated in order to convert Zig struct " ++ type_name ++ " to Python object",
+                        .n_in_sequence = fields.len - 1,
+                        // Fully qualified name would be too verbose
+                        .name = comptime name: {
+                            var name: []const u8 = undefined;
+                            var tokenizer = std.mem.tokenize(u8, type_name, ".");
+                            while (tokenizer.next()) |token| {
+                                name = token;
+                            }
+                            break :name "import_zig." ++ name ++ "";
+                        },
+                        .fields = &fields,
+                    };
+                    const tp = py.PyStructSequence_NewType(&desc) orelse return PyErr.PyErr;
+
+                    try struct_tuple_map.put(type_name, tp);
+
+                    break :blk_tp tp;
+                };
+
+                const tuple = py.PyStructSequence_New(tuple_type) orelse return PyErr.PyErr;
+                errdefer py.Py_DECREF(tuple);
+                inline for (info.fields, 0..) |field, i_field| {
+                    const py_value = try zig_to_py(@field(value, field.name));
+                    py.PyStructSequence_SetItem(tuple, @intCast(i_field), py_value);
+                }
+                break :blk tuple;
+            }
+        },
+        else => |info| {
+            @compileLog("unsupported py-type conversion", info);
+            comptime unreachable;
+        },
+    } orelse return PyErr.PyErr;
+}
+
+/// Parse Python value into Zig type. Memory management for strings is handled by Python.
+/// This also means that once the original Python string is garbage collected the pointer is dangling.
+/// Similary, when a PyObject is requested, the reference is borrowed.
+pub fn py_to_zig(zig_type: type, py_value: *py.PyObject, allocator: ?std.mem.Allocator) !zig_type {
+    switch (@typeInfo(zig_type)) {
+        .Int => |info| {
+            const val = if (info.signedness == .signed) py.PyLong_AsLongLong(py_value) else py.PyLong_AsUnsignedLongLong(py_value);
+            if (py.PyErr_Occurred() != null) {
+                return PyErr.PyErr;
+            }
+            return std.math.cast(zig_type, val) orelse return raise(.ValueError, "Expected integer to fit into {any}", .{zig_type});
+        },
+        .Float => {
+            const val: zig_type = @floatCast(py.PyFloat_AsDouble(py_value));
+            if (py.PyErr_Occurred() != null) {
+                return PyErr.PyErr;
+            }
+            return val;
+        },
+        .Bool => {
+            switch (py.PyObject_IsTrue(py_value)) {
+                -1 => return PyErr.PyErr,
+                0 => return false,
+                1 => return true,
+                else => unreachable,
+            }
+        },
+        .Optional => |info| {
+            switch (py.Py_IsNone(py_value)) {
+                1 => return null,
+                0 => return try py_to_zig(info.child, py_value, allocator),
+                else => unreachable,
+            }
+        },
+        .Array => |info| {
+            if (info.sentinel) |_| @compileError("Sentinel is not supported");
+            switch (py.PyObject_Length(py_value)) {
+                -1 => return PyErr.PyErr,
+                info.len => {},
+                else => |len| return raise(.TypeError, "Sequence had length {}, expected {}", .{ len, info.len }),
+            }
+            var zig_value: zig_type = undefined;
+            for (0..info.len) |i| {
+                const py_value_inner = py.PySequence_GetItem(py_value, @intCast(i)) orelse return PyErr.PyErr;
+                defer py.Py_DECREF(py_value_inner);
+                zig_value[i] = try py_to_zig(info.child, py_value_inner, allocator);
+            }
+            return zig_value;
+        },
+        .Pointer => |info| {
+            switch (info.size) {
+                .One => {
+                    if (info.child == py.PyObject) {
+                        return py_value;
+                    } else @compileError("Only PyObject is supported for One-Pointer");
+                },
+                .Many => @compileError("Many Pointer not supported"),
+                .Slice => {
+                    if (info.child == u8) {
+                        var size: py.Py_ssize_t = -1;
+                        const char_ptr = py.PyUnicode_AsUTF8AndSize(py_value, &size) orelse return PyErr.PyErr;
+                        if (size < 0) {
+                            return PyErr.PyErr;
+                        }
+                        return char_ptr[0..@intCast(size)];
+                    } else {
+                        const len: usize = blk: {
+                            const py_len = py.PyObject_Length(py_value);
+                            if (py_len < 0) {
+                                return PyErr.PyErr;
+                            }
+                            break :blk @intCast(py_len);
+                        };
+                        const slice = allocator.?.alloc(info.child, len) catch {
+                            _ = py.PyErr_NoMemory();
+                            return PyErr.PyErr;
+                        };
+                        for (slice, 0..) |*entry, i_entry| {
+                            const py_entry = py.PySequence_GetItem(py_value, @intCast(i_entry)) orelse return PyErr.PyErr;
+                            entry.* = try py_to_zig(info.child, py_entry, allocator);
+                        }
+                        return slice;
+                    }
+                },
+                .C => @compileError("C Pointer not supported"),
+            }
+        },
+        .Struct => |info| {
+            var zig_value: zig_type = undefined;
+            if (info.fields.len == 0) {
+                return zig_value;
+            }
+            if (py.PyDict_Check(py_value) != 0) {
+                comptime var n_fields = 0;
+                inline for (info.fields) |field| {
+                    const py_value_inner = py.PyDict_GetItemString(
+                        py_value,
+                        field.name,
+                    ) orelse {
+                        return raise(.TypeError, "Could not get dict value for key={s}", .{field.name});
+                    };
+                    @field(zig_value, field.name) = try py_to_zig(
+                        field.type,
+                        py_value_inner,
+                        allocator,
+                    );
+                    n_fields += 1;
+                }
+                switch (py.PyObject_Length(py_value)) {
+                    -1 => return PyErr.PyErr,
+                    n_fields => return zig_value,
+                    else => |len| return raise(.TypeError, "Dict had length {}, expected {}", .{ len, n_fields }),
+                }
+            } else {
+                comptime var n_fields = 0;
+                inline for (info.fields) |field| {
+                    const py_value_inner = py.PySequence_GetItem(py_value, n_fields) orelse return PyErr.PyErr;
+                    defer py.Py_DECREF(py_value_inner);
+                    @field(zig_value, field.name) = try py_to_zig(
+                        field.type,
+                        py_value_inner,
+                        allocator,
+                    );
+                    n_fields += 1;
+                }
+                switch (py.PyObject_Length(py_value)) {
+                    -1 => return PyErr.PyErr,
+                    n_fields => return zig_value,
+                    else => |len| return raise(.TypeError, "Sequence had length {}, expected {}", .{ len, n_fields }),
+                }
+                return zig_value;
+            }
+        },
+        else => {},
+    }
+    @compileLog("Unsupported conversion from py to zig", @typeInfo(zig_type));
+    comptime unreachable;
+}

import_zig-0.13.0/import_zig/zig_ext.zig

@@ -0,0 +1,136 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const generated = @import("generated.zig");
+const pyu = @import("py_utils.zig");
+const py = pyu.py;
+const zig_file = @import("inner/import_fns.zig");
+
+fn list_to_arr(T: type, list: *std.SinglyLinkedList(T)) [list.len()]T {
+    var arr: [list.len()]T = undefined;
+    var idx: usize = list.len();
+    while (list.popFirst()) |node| {
+        idx -= 1;
+        arr[idx] = node.data;
+    }
+    std.debug.assert(idx == 0);
+    return arr;
+}
+
+var zig_ext_methods = blk: {
+    var methods = std.SinglyLinkedList(py.PyMethodDef){ .first = null };
+    const methods_node = @TypeOf(methods).Node;
+
+    for (@typeInfo(zig_file).Struct.decls) |fn_decl| {
+        const zig_func = @field(zig_file, fn_decl.name);
+        if (@typeInfo(@TypeOf(zig_func)) != .Fn) continue;
+        const fn_info = @typeInfo(@TypeOf(zig_func)).Fn;
+
+        var i_allocator: isize = -1;
+        const arg_type = std.meta.Tuple(&T: {
+            var types: [fn_info.params.len]type = undefined;
+            for (fn_info.params, 0..) |param, i_type| {
+                const T = param.type.?;
+                types[i_type] = T;
+                if (T == std.mem.Allocator) {
+                    if (i_allocator != -1) {
+                        @compileError("Can only request allocator once per function");
+                    }
+                    i_allocator = i_type;
+                }
+            }
+            break :T types;
+        });
+
+        const n_py_args = if (i_allocator != -1) fn_info.params.len - 1 else fn_info.params.len;
+
+        const wrapper = struct {
+            fn wrapper(_: ?*py.PyObject, py_args: [*]*py.PyObject, n_py_args_runtime: isize) callconv(.C) ?*py.PyObject {
+                var arena = std.heap.ArenaAllocator.init(pyu.gp_allocator);
+                defer arena.deinit();
+                const allocator = arena.allocator();
+                var args: arg_type = undefined;
+                if (n_py_args != n_py_args_runtime) {
+                    pyu.raise(.Exception, "Expected {} arguments, received {}", .{ n_py_args, n_py_args_runtime }) catch {};
+                    return null;
+                }
+                inline for (@typeInfo(arg_type).Struct.fields, 0..) |field, i_field| {
+                    if (i_field == i_allocator) {
+                        @field(args, field.name) = allocator;
+                        continue;
+                    }
+                    const py_arg = py_args[i_field - @intFromBool(i_allocator != -1 and i_field > i_allocator)];
+                    @field(args, field.name) = pyu.py_to_zig(field.type, py_arg, allocator) catch {
+                        pyu.raise(.Exception, "Error converting function arguments to zig types", .{}) catch {};
+                        return null;
+                    };
+                }
+
+                const zig_ret = @call(.always_inline, zig_func, args);
+
+                const zig_ret_unwrapped = if (@typeInfo(@TypeOf(zig_ret)) == .ErrorUnion)
+                    zig_ret catch |err| {
+                        if (err != pyu.PyErr.PyErr) {
+                            pyu.raise(.Exception, "Zig function returned an error: {any}", .{err}) catch {};
+                        }
+                        return null;
+                    }
+                else
+                    zig_ret;
+
+                return pyu.zig_to_py(zig_ret_unwrapped) catch {
+                    pyu.raise(.Exception, "Error converting zig return values to python types", .{}) catch {};
+                    return null;
+                };
+            }
+        }.wrapper;
+
+        var node = methods_node{
+            .data = py.PyMethodDef{
+                .ml_name = fn_decl.name,
+                .ml_meth = @ptrCast(&wrapper),
+                .ml_flags = py.METH_FASTCALL,
+                .ml_doc = null,
+            },
+        };
+        methods.prepend(&node);
+    }
+    var node = methods_node{
+        .data = py.PyMethodDef{
+            .ml_name = null,
+            .ml_meth = null,
+            .ml_flags = 0,
+            .ml_doc = null,
+        },
+    };
+    methods.prepend(&node);
+    break :blk list_to_arr(py.PyMethodDef, &methods);
+};
+
+var zig_ext_module = py.PyModuleDef{
+    .m_base = py.PyModuleDef_Base{
+        .ob_base = py.PyObject{
+            // .ob_refcnt = 1,
+            .ob_type = null,
+        },
+        .m_init = null,
+        .m_index = 0,
+        .m_copy = null,
+    },
+    .m_name = "zig_ext",
+    .m_doc = null,
+    .m_size = -1,
+    .m_methods = &zig_ext_methods,
+    .m_slots = null,
+    .m_traverse = null,
+    .m_clear = null,
+    .m_free = null,
+};
+
+fn init() callconv(.C) ?*py.PyObject {
+    const module = py.PyModule_Create(&zig_ext_module);
+    return module;
+}
+
+comptime {
+    @export(init, .{ .name = "PyInit_" ++ generated.module_name, .linkage = .strong });
+}

import_zig-0.13.0/import_zig.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: import_zig
+Version: 0.13.0
+Summary: Compile and import Zig functions at runtime without building a package
+Author: Felix Graßl
+License: MIT
+Project-URL: Homepage, https://github.com/ffelixg/import_zig
+Project-URL: Issues, https://github.com/ffelixg/import_zig/issues
+Keywords: zig,ziglang,import,compile
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ziglang==0.13
+
+# import-zig
+
+    pip install import-zig
+
+This module provides a way to import Zig code directly into Python using a single function call to `import_zig`. Here is an example:
+
+```py
+from import_zig import import_zig
+
+mod = import_zig(source_code = """
+    pub fn Q_rsqrt(number: f32) f32 {
+        const threehalfs: f32 = 1.5;
+        const x2 = number * 0.5;
+        var y = number;
+        var i: i32 = @bitCast(y);
+        i = 0x5f3759df - (i >> 1);
+        y = @bitCast(i);
+        y = y * (threehalfs - (x2 * y * y));
+
+        return y;
+    }
+""")
+
+print(f"1 / sqrt(1.234) = {mod.Q_rsqrt(1.234)}")
+```
+
+The main goal of this module is to make it easy to prototype Zig extensions for Python without having to engage with the Python build system. When building larger Zig extensions it is likely preferable to write your own build process with setuptools or to use a ziggy-pydust template, which provides a comptime abstraction over many aspects of the Python C API. Zig and Zig extensions are still very new though, so things will likely change. Technically you could also use this module as part of a packaging step by calling the `compile_to` function to build the binary and moving it into the packages build folder.
+
+One approach that I expect to stay the same is the comptime wrapping for conversion between Zig and Python types as well as exception handling. This is conveniently packed into the file `py_utils.zig` and could be copy pasted into a new setuptools based project and maybe adjusted.
+
+See the docs of the import_zig function for more details or check out the examples directory.
+
+# File structure
+
+The file structure that will be generated to compile the Zig code looks as follows.
+
+```bash
+project_folder
+├── build.zig
+├── generated.zig
+├── inner
+│   └── import_fns.zig
+├── py_utils.zig
+└── zig_ext.zig
+```
+
+The `inner` directory is where your code lives. When you pass a source code string or file path, it will be written / linked as the `import_fns.zig` file. When you pass a directory path, the directory will be linked as the `inner` directory above, enabling references to other files in the directory path.
+
+The above file structure can be generated with:
+
+```py
+import_zig.prepare("/path/to/project_folder", "module_name")
+```
+
+This enables ZLS support for the Python C API when importing `py_utils` from `import_fns.zig`.
+
+# Type mapping
+
+The conversion is defined in `py_utils.zig` and applied based on the parameter / return types of the exported function. Errors are also forwarded. The solution to passing variable length data back to Python is a bit of a hack: When an exported function specifies `std.mem.Allocator` as a parameter type, then an arena allocator - which gets deallocated after the function call - will be passed into the function. The allocator can then be used to allocate and return new slices for example.
+
+For nested types, the conversion is applied recursively.
+
+| Conversion from Python                  | Zig datatype                      | Conversion to Python                          |
+| --------------------------------------- | --------------------------------- | --------------------------------------------- |
+| int                                     | integer (any size / sign)         | int                                           |
+| float                                   | float (any size)                  | float                                         |
+| -                                       | void                              | None                                          |
+| evaluated like bool()                   | bool                              | bool                                          |
+| sequence                                | array                             | list                                          |
+| sequence                                | non u8 const slice                | list                                          |
+| str                                     | u8 const slice                    | str                                           |
+| dict or sequence                        | struct                            | tuple if struct is a tuple or named tuple     |
+| comparison with None                    | optional                          | null -> None                                  |

import_zig-0.13.0/import_zig.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+import_zig/__init__.py
+import_zig/build.zig
+import_zig/py_utils.zig
+import_zig/zig_ext.zig
+import_zig.egg-info/PKG-INFO
+import_zig.egg-info/SOURCES.txt
+import_zig.egg-info/dependency_links.txt
+import_zig.egg-info/requires.txt
+import_zig.egg-info/top_level.txt

import_zig-0.13.0/import_zig.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

import_zig-0.13.0/import_zig.egg-info/requires.txt

@@ -0,0 +1 @@
+ziglang==0.13

import_zig-0.13.0/import_zig.egg-info/top_level.txt

@@ -0,0 +1 @@
+import_zig

import_zig-0.13.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "import_zig"
+authors = [{name = "Felix Graßl"}]
+description = "Compile and import Zig functions at runtime without building a package"
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["zig", "ziglang", "import", "compile"]
+license = {text = "MIT"}
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+dependencies = ["ziglang==0.13"]
+version = "0.13.0"
+
+[project.urls]
+Homepage = "https://github.com/ffelixg/import_zig"
+Issues = "https://github.com/ffelixg/import_zig/issues"
+
+[tool.setuptools]
+py-modules = ["import_zig"]
+packages = ["import_zig"]
+package-data = {import_zig = ["*.zig"]}

import_zig-0.13.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+