implement more interfaces

6 files changed, 78 insertions, 12 deletions

diff --git a/src/Object.zig b/src/Object.zig
index 782071f..018d8b3 100644
--- a/src/Object.zig
+++ b/src/Object.zig
@@ -23,9 +23,9 @@ pub fn repr(self: *const Self) zpy.Str {
     return .{ .object = .fromPtr(c.PyObject_Repr(self.ptr)) };
 }
 
-pub fn call(self: *Self, args: anytype) zpy.Error!zpy.Object {
-    _ = args;
-    if (c.PyObject_CallObject(self.ptr, null)) |object| {
+pub fn call(self: *Self, args: zpy.Tuple, kwargs: ?zpy.Dict) zpy.Error!zpy.Object {
+    const kwargs_ptr: ?*c.PyObject = if (kwargs) |kw| kw.object.ptr else null;
+    if (c.PyObject_Call(self.ptr, args.object.ptr, kwargs_ptr)) |object| {
         return .fromPtr(object);
     }
 
diff --git a/src/Str.zig b/src/Str.zig
index eaca378..8f49c61 100644
--- a/src/Str.zig
+++ b/src/Str.zig
@@ -1,11 +1,17 @@
 
 const c = @import("c");
 const zpy = @import("root.zig");
+const conversion = zpy.conversion;
 
 const Self = @This();
 
 object: zpy.Object,
 
+pub fn fromString(buffer: []const u8) Self {
+    return .{
+        .object = .fromPtr(c.PyUnicode_FromStringAndSize(@ptrCast(buffer), @intCast(buffer.len)))
+    };
+}
 
 pub fn asUtf8(self: *Self) zpy.Error![]const u8 {
     var size: c.Py_ssize_t = undefined;
diff --git a/src/Tuple.zig b/src/Tuple.zig
new file mode 100644
index 0000000..ceb1711
--- /dev/null
+++ b/src/Tuple.zig
@@ -0,0 +1,37 @@
+
+const c = @import("c");
+const zpy = @import("root.zig");
+const conversion = zpy.conversion;
+
+const Self = @This();
+
+object: zpy.Object,
+
+pub fn new(length: usize) !Self {
+    return .{
+        .object = .fromPtr(try conversion.Ptr(c.PyTuple_New(@intCast(length)))),
+    };
+}
+
+pub fn pack(values: []const zpy.Object) !Self {
+    var tuple = try new(values.len);
+    errdefer tuple.object.decref();
+
+    for (values, 0..) |value, index| {
+        try tuple.set(index, value);
+    }
+
+    return tuple;
+}
+
+pub fn size(self: *const Self) usize {
+    return c.PyTuple_GET_SIZE(self.object.ptr);
+}
+
+pub fn get(self: *Self, index: usize) zpy.Error!zpy.Object {
+    return .fromPtr(conversion.Ptr(c.PyTuple_GetItem(self.object.ptr, @intCast(index))) catch return error.IndexError);
+}
+
+pub fn set(self: *Self, index: usize, value: zpy.Object) zpy.Error!void {
+    conversion.success(c.PyTuple_SetItem(self.object.ptr, @intCast(index), value.ptr)) catch return error.IndexError;
+}
diff --git a/src/function.zig b/src/function.zig
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/function.zig
@@ -0,0 +1 @@
+
diff --git a/src/main.zig b/src/main.zig
index a39c79f..0cd2ec5 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -7,16 +7,16 @@ pub fn main() !void {
     var py: zpy.Interpreter = try .init();
     defer py.deinit();
 
-    var locals = try zpy.Dict.new();
-    defer locals.deinit();
+    _ = try py.run("def hello(a, b): return a + b", .{ });
 
-    _ = try py.run("def test(): print('hello')", .{
-        .locals = &locals,
-    });
-
-    var test_fn = locals.get(.{ .string = "test" }) orelse unreachable;
+    var test_fn = py.globals.get(.{ .string = "hello" }) orelse unreachable;
     defer test_fn.decref();
-    const result = try test_fn.call(.{});
+    var result = try test_fn.call(try .pack(&.{
+        zpy.Str.fromString("hello").object,
+        zpy.Str.fromString("world").object,
+    }), null);
+    defer result.decref();
 
-    std.debug.print("test() = {f}\n", .{result});
+    std.debug.print("globals = {f}\n", .{py.globals.object});
+    std.debug.print("hello() = {f}\n", .{result});
 }
diff --git a/src/root.zig b/src/root.zig
index 0e3d9e4..471267f 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -4,7 +4,29 @@ pub const Object = @import("Object.zig");
 pub const Interpreter = @import("Interpreter.zig");
 pub const Dict = @import("Dict.zig");
 pub const Str = @import("Str.zig");
+pub const Tuple = @import("Tuple.zig");
+pub const Fn = @import("function.zig").Fn;
 
 pub const Error = error {
     Exception,
+    IndexError,
+};
+
+pub const conversion = struct {
+    fn PtrFromCPtr(T: type) type {
+        const info = @typeInfo(T);
+        return *info.pointer.child;
+    }
+
+    pub fn Ptr(value: anytype) Error!PtrFromCPtr(@TypeOf(value)) {
+        if (value) |ptr| {
+            return ptr;
+        }
+
+        return error.Exception;
+    }
+
+    pub fn success(value: c_int) Error!void {
+        if (value == -1) return error.Exception;
+    }
 };