Fix trampoline optionals

pydust/src/functions.zig

@@ -435,7 +435,7 @@ fn valueToStr(comptime T: type, value: *const anyopaque) []const u8 {
         },
         inline .Bool => if (@as(*const bool, @ptrCast(value)).*) "True" else "False",
         inline .Struct => "...",
-        inline .Optional => if (value == null) "None" else "...",
+        inline .Optional => |o| if (@as(*const ?o.child, @alignCast(@ptrCast(value))).* == null) "None" else "...",
         inline else => std.fmt.comptimePrint("{any}", .{@as(*const T, @alignCast(@ptrCast(value))).*}),
     };
 }

pydust/src/pydust.zig

@@ -21,13 +21,13 @@ const pytypes = @import("pytypes.zig");
 const ClassDef = pytypes.ClassDef;
 const funcs = @import("functions.zig");
 const tramp = @import("trampoline.zig");
-const PyError = @import("errors.zig").PyError;
 
 // Export some useful things for users
 pub usingnamespace builtins;
 pub usingnamespace conversions;
 pub usingnamespace types;
 pub const ffi = @import("ffi.zig");
+pub const PyError = @import("errors.zig").PyError;
 pub const allocator: std.mem.Allocator = mem.PyMemAllocator.allocator();
 
 const Self = @This();

pydust/src/trampoline.zig

@@ -207,20 +207,20 @@ pub fn Trampoline(comptime T: type) type {
 
         /// Unwrap a Python object into a Zig object. Does not steal a reference.
         /// The Python object must be the correct corresponding type (vs a cast which coerces values).
-        pub inline fn unwrap(object: ?py.PyObject) !T {
+        pub inline fn unwrap(object: ?py.PyObject) py.PyError!T {
             // Handle the error case explicitly, then we can unwrap the error case entirely.
             const typeInfo = @typeInfo(T);
 
             // Early return to handle errors
             if (typeInfo == .ErrorUnion) {
                 const value = object catch |err| return err;
-                return Trampoline(typeInfo.ErrorUnion.payload).unwrap(value);
+                return @as(T, Trampoline(typeInfo.ErrorUnion.payload).unwrap(value));
             }
 
             // Early return to handle optionals
             if (typeInfo == .Optional) {
                 const value = object orelse return null;
-                return Trampoline(typeInfo.Optional.child).unwrap(value);
+                return @as(T, try Trampoline(typeInfo.Optional.child).unwrap(value));
             }
 
             // Otherwise we can unwrap the object.

pydust/src/types/str.zig

@@ -28,6 +28,13 @@ pub const PyString = extern struct {
         return .{ .obj = .{ .py = unicode } };
     }
 
+    pub fn fmt(comptime format: []const u8, args: anytype) !py.PyString {
+        const str = try std.fmt.allocPrint(py.allocator, format, args);
+        defer py.allocator.free(str);
+
+        return create(str);
+    }
+
     /// Append other to self.
     ///
     /// Warning: a reference to self is stolen. Use concat, or self.incref(), if you don't own a reference to self.