Merge pull request #6 from cpunion/fix

better func names, fix ref counting and memory free, add tests

Author: cpunion

_demo/autoderef/autoderef.go

@@ -13,7 +13,7 @@ func main() {
 	gp.Initialize()
 	defer gp.Finalize()
 	fooMod := foo.InitFooModule()
-	gp.GetModuleDict().Set(gp.MakeStr("foo").Object, fooMod.Object)
+	gp.GetModuleDict().SetString("foo", fooMod)
 
 	Main1(fooMod)
 	Main2()
@@ -22,21 +22,21 @@ func main() {
 
 func Main1(fooMod gp.Module) {
 	fmt.Printf("=========== Main1 ==========\n")
-	sum := fooMod.Call("add", gp.MakeLong(1), gp.MakeLong(2)).AsLong()
+	sum := fooMod.Call("add", 1, 2).AsLong()
 	fmt.Printf("Sum of 1 + 2: %d\n", sum.Int64())
 
 	dict := fooMod.Dict()
 	Point := dict.Get(gp.MakeStr("Point")).AsFunc()
 
-	point := Point.Call(gp.MakeLong(3), gp.MakeLong(4))
+	point := Point.Call(3, 4)
 	fmt.Printf("dir(point): %v\n", point.Dir())
-	fmt.Printf("x: %v, y: %v\n", point.GetAttr("x"), point.GetAttr("y"))
+	fmt.Printf("x: %v, y: %v\n", point.Attr("x"), point.Attr("y"))
 
 	distance := point.Call("distance").AsFloat()
 	fmt.Printf("Distance of 3 * 4: %f\n", distance.Float64())
 
-	point.Call("move", gp.MakeFloat(1), gp.MakeFloat(2))
-	fmt.Printf("x: %v, y: %v\n", point.GetAttr("x"), point.GetAttr("y"))
+	point.Call("move", 1, 2)
+	fmt.Printf("x: %v, y: %v\n", point.Attr("x"), point.Attr("y"))
 
 	distance = point.Call("distance").AsFloat()
 	fmt.Printf("Distance of 4 * 6: %f\n", distance.Float64())
@@ -45,7 +45,7 @@ func Main1(fooMod gp.Module) {
 
 func Main2() {
 	fmt.Printf("=========== Main2 ==========\n")
-	gp.RunString(`
+	_ = gp.RunString(`
 import foo
 point = foo.Point(3, 4)
 print("dir(point):", dir(point))
@@ -92,7 +92,7 @@ for i in range(10):
 		fmt.Printf("Iteration %d in python\n", i+1)
 	}
 
-	memory_allocation_test := mod.GetFuncAttr("memory_allocation_test")
+	memory_allocation_test := mod.AttrFunc("memory_allocation_test")
 
 	for i := 0; i < 100; i++ {
 		// 100MB every time

_demo/gradio/gradio.go

@@ -60,7 +60,7 @@ func main() {
 		})
 		textbox := gr.Call("Textbox")
 		examples := gr.Call("Examples", [][]string{{"Chicago"}, {"Little Rock"}, {"San Francisco"}}, textbox)
-		dataset := examples.GetAttr("dataset")
+		dataset := examples.Attr("dataset")
 		dropdown.Call("change", fn, dropdown, dataset)
 	})
 	demo.Call("launch")

_demo/plot/plot.go

@@ -22,6 +22,6 @@ func main() {
 	gp.Initialize()
 	defer gp.Finalize()
 	plt := Plt()
-	plt.Plot(gp.MakeTuple(5, 10), gp.MakeTuple(10, 15), gp.KwArgs{"color": "red"})
+	plt.Plot([]int{5, 10}, []int{10, 15}, gp.KwArgs{"color": "red"})
 	plt.Show()
 }

adap_go.go

@@ -18,6 +18,10 @@ func AllocCStr(s string) *C.char {
 	return C.CString(s)
 }
 
+func AllocCStrDontFree(s string) *C.char {
+	return C.CString(s)
+}
+
 func AllocWCStr(s string) *C.wchar_t {
 	runes := []rune(s)
 	wchars := make([]uint16, len(runes)+1)

bytes.go

@@ -22,12 +22,14 @@ func BytesFromStr(s string) Bytes {
 
 func MakeBytes(bytes []byte) Bytes {
 	ptr := C.CBytes(bytes)
-	return newBytes(C.PyBytes_FromStringAndSize((*C.char)(ptr), C.Py_ssize_t(len(bytes))))
+	o := C.PyBytes_FromStringAndSize((*C.char)(ptr), C.Py_ssize_t(len(bytes)))
+	C.free(unsafe.Pointer(ptr))
+	return newBytes(o)
 }
 
 func (b Bytes) Bytes() []byte {
-	var p *byte
-	var l int
+	p := (*byte)(unsafe.Pointer(C.PyBytes_AsString(b.obj)))
+	l := int(C.PyBytes_Size(b.obj))
 	return C.GoBytes(unsafe.Pointer(p), C.int(l))
 }
 

dict.go

@@ -4,7 +4,10 @@ package gp
 #include <Python.h>
 */
 import "C"
-import "fmt"
+import (
+	"fmt"
+	"unsafe"
+)
 
 type Dict struct {
 	Object
@@ -47,26 +50,32 @@ func (d Dict) Get(key Objecter) Object {
 	return newObject(v)
 }
 
-func (d Dict) Set(key, value Object) {
-	C.Py_IncRef(key.obj)
-	C.Py_IncRef(value.obj)
-	C.PyDict_SetItem(d.obj, key.obj, value.obj)
+func (d Dict) Set(key, value Objecter) {
+	keyObj := key.Obj()
+	valueObj := value.Obj()
+	C.PyDict_SetItem(d.obj, keyObj, valueObj)
 }
 
-func (d Dict) SetString(key string, value Object) {
-	C.Py_IncRef(value.obj)
-	C.PyDict_SetItemString(d.obj, AllocCStr(key), value.obj)
+func (d Dict) SetString(key string, value Objecter) {
+	valueObj := value.Obj()
+	ckey := AllocCStr(key)
+	r := C.PyDict_SetItemString(d.obj, ckey, valueObj)
+	C.free(unsafe.Pointer(ckey))
+	if r != 0 {
+		panic(fmt.Errorf("failed to set item string: %v", r))
+	}
 }
 
 func (d Dict) GetString(key string) Object {
-	v := C.PyDict_GetItemString(d.obj, AllocCStr(key))
+	ckey := AllocCStr(key)
+	v := C.PyDict_GetItemString(d.obj, ckey)
 	C.Py_IncRef(v)
+	C.free(unsafe.Pointer(ckey))
 	return newObject(v)
 }
 
-func (d Dict) Del(key Object) {
-	C.PyDict_DelItem(d.obj, key.obj)
-	C.Py_DecRef(key.obj)
+func (d Dict) Del(key Objecter) {
+	C.PyDict_DelItem(d.obj, key.Obj())
 }
 
 func (d Dict) ForEach(fn func(key, value Object)) {
@@ -84,6 +93,9 @@ func (d Dict) ForEach(fn func(key, value Object)) {
 		C.Py_IncRef(item)
 		key := C.PyTuple_GetItem(item, 0)
 		value := C.PyTuple_GetItem(item, 1)
+		C.Py_IncRef(key)
+		C.Py_IncRef(value)
+		C.Py_DecRef(item)
 		fn(newObject(key), newObject(value))
 	}
 }

float.go

@@ -22,6 +22,6 @@ func (f Float) Float64() float64 {
 }
 
 func (f Float) IsInteger() Bool {
-	fn := Cast[Func](f.GetAttr("is_integer"))
+	fn := Cast[Func](f.Attr("is_integer"))
 	return Cast[Bool](fn.callNoArgs())
 }

function.go

@@ -154,7 +154,7 @@ func wrapperInit(self, args *C.PyObject) C.int {
 }
 
 //export getterMethod
-func getterMethod(self *C.PyObject, closure unsafe.Pointer, methodId C.int) *C.PyObject {
+func getterMethod(self *C.PyObject, _closure unsafe.Pointer, methodId C.int) *C.PyObject {
 	typeMeta := typeMetaMap[(*C.PyObject)(unsafe.Pointer(self.ob_type))]
 	if typeMeta == nil {
 		SetError(fmt.Errorf("type %v not registered", FromPy(self)))
@@ -177,7 +177,7 @@ func getterMethod(self *C.PyObject, closure unsafe.Pointer, methodId C.int) *C.P
 }
 
 //export setterMethod
-func setterMethod(self, value *C.PyObject, closure unsafe.Pointer, methodId C.int) C.int {
+func setterMethod(self, value *C.PyObject, _closure unsafe.Pointer, methodId C.int) C.int {
 	typeMeta := typeMetaMap[(*C.PyObject)(unsafe.Pointer(self.ob_type))]
 	if typeMeta == nil {
 		SetError(fmt.Errorf("type %v not registered", FromPy(self)))
@@ -260,6 +260,7 @@ func wrapperMethod_(typeMeta *typeMeta, methodMeta *slotMeta, self, args *C.PyOb
 
 	for i := 0; i < int(argc); i++ {
 		arg := C.PyTuple_GetItem(args, C.Py_ssize_t(i))
+		C.Py_IncRef(arg)
 		argType := methodType.In(i + argIndex)
 		argPy := FromPy(arg)
 		goValue := reflect.New(argType).Elem()
@@ -316,7 +317,7 @@ func getMethods_(t reflect.Type, methods map[uint]*slotMeta) (ret []C.PyMethodDe
 			methodPtr := C.wrapperMethods[methodId]
 
 			ret = append(ret, C.PyMethodDef{
-				ml_name:  C.CString(pythonName),
+				ml_name:  AllocCStrDontFree(pythonName),
 				ml_meth:  (C.PyCFunction)(unsafe.Pointer(methodPtr)),
 				ml_flags: C.METH_VARARGS,
 				ml_doc:   nil,
@@ -402,7 +403,7 @@ func getMembers(t reflect.Type, methods map[uint]*slotMeta) (members *C.PyMember
 		if memberType != -1 {
 			// create as member variable for C-compatible types
 			membersList = append(membersList, C.PyMemberDef{
-				name:   C.CString(pythonName),
+				name:   AllocCStrDontFree(pythonName),
 				_type:  memberType,
 				offset: C.Py_ssize_t(baseOffset + field.Offset),
 			})
@@ -429,7 +430,7 @@ func getMembers(t reflect.Type, methods map[uint]*slotMeta) (members *C.PyMember
 				index:      i,
 			}
 			getsetsList = append(getsetsList, C.PyGetSetDef{
-				name:    C.CString(pythonName),
+				name:    AllocCStrDontFree(pythonName),
 				get:     C.getterMethods[getId],
 				set:     C.setterMethods[setId],
 				doc:     nil,
@@ -480,9 +481,6 @@ func AddType[T any](m Module, init any, name string, doc string) Object {
 		methods: make(map[uint]*slotMeta),
 	}
 
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
 	slots := make([]C.PyType_Slot, 0)
 	if init != nil {
 		slots = append(slots, C.PyType_Slot{slot: C.Py_tp_init, pfunc: unsafe.Pointer(C.wrapperInit)})
@@ -512,7 +510,7 @@ func AddType[T any](m Module, init any, name string, doc string) Object {
 	}
 
 	spec := &C.PyType_Spec{
-		name:      cname,
+		name:      C.CString(name),
 		basicsize: C.int(unsafe.Sizeof(wrapper)),
 		flags:     C.Py_TPFLAGS_DEFAULT,
 		slots:     slotsPtr,
@@ -526,7 +524,7 @@ func AddType[T any](m Module, init any, name string, doc string) Object {
 	typeMetaMap[typeObj] = meta
 	pyTypeMap[ty] = typeObj
 
-	if C.PyModule_AddObject(m.obj, cname, typeObj) < 0 {
+	if C.PyModule_AddObject(m.obj, C.CString(name), typeObj) < 0 {
 		C.Py_DecRef(typeObj)
 		panic(fmt.Sprintf("Failed to add type %s to module", name))
 	}
@@ -599,14 +597,14 @@ func (m Module) AddMethod(name string, fn any, doc string) Func {
 
 func SetError(err error) {
 	errStr := C.CString(err.Error())
-	defer C.free(unsafe.Pointer(errStr))
 	C.PyErr_SetString(C.PyExc_RuntimeError, errStr)
+	C.free(unsafe.Pointer(errStr))
 }
 
 func SetTypeError(err error) {
 	errStr := C.CString(err.Error())
-	defer C.free(unsafe.Pointer(errStr))
 	C.PyErr_SetString(C.PyExc_TypeError, errStr)
+	C.free(unsafe.Pointer(errStr))
 }
 
 // FetchError returns the current Python error as a Go error

list.go

@@ -28,14 +28,16 @@ func (l List) GetItem(index int) Object {
 	return newObject(v)
 }
 
-func (l List) SetItem(index int, item Object) {
-	C.PyList_SetItem(l.obj, C.Py_ssize_t(index), item.obj)
+func (l List) SetItem(index int, item Objecter) {
+	itemObj := item.Obj()
+	C.Py_IncRef(itemObj)
+	C.PyList_SetItem(l.obj, C.Py_ssize_t(index), itemObj)
 }
 
 func (l List) Len() int {
 	return int(C.PyList_Size(l.obj))
 }
 
-func (l List) Append(obj Object) {
-	C.PyList_Append(l.obj, obj.obj)
+func (l List) Append(obj Objecter) {
+	C.PyList_Append(l.obj, obj.Obj())
 }

long.go

@@ -4,6 +4,7 @@ package gp
 #include <Python.h>
 */
 import "C"
+import "unsafe"
 
 type Long struct {
 	Object
@@ -35,7 +36,9 @@ func LongFromFloat64(v float64) Long {
 
 func LongFromString(s string, base int) Long {
 	cstr := AllocCStr(s)
-	return newLong(C.PyLong_FromString(cstr, nil, C.int(base)))
+	o := C.PyLong_FromString(cstr, nil, C.int(base))
+	C.free(unsafe.Pointer(cstr))
+	return newLong(o)
 }
 
 func LongFromUnicode(u Object, base int) Long {

module.go

@@ -4,6 +4,7 @@ package gp
 #include <Python.h>
 */
 import "C"
+import "unsafe"
 
 type Module struct {
 	Object
@@ -14,7 +15,9 @@ func newModule(obj *PyObject) Module {
 }
 
 func ImportModule(name string) Module {
-	mod := C.PyImport_ImportModule(AllocCStr(name))
+	cname := AllocCStr(name)
+	mod := C.PyImport_ImportModule(cname)
+	C.free(unsafe.Pointer(cname))
 	return newModule(mod)
 }
 
@@ -27,11 +30,15 @@ func (m Module) Dict() Dict {
 }
 
 func (m Module) AddObject(name string, obj Object) int {
-	return int(C.PyModule_AddObject(m.obj, AllocCStr(name), obj.obj))
+	cname := AllocCStr(name)
+	r := int(C.PyModule_AddObject(m.obj, cname, obj.obj))
+	C.free(unsafe.Pointer(cname))
+	return r
 }
 
 func CreateModule(name string) Module {
-	return newModule(C.PyModule_New(AllocCStr(name)))
+	mod := C.PyModule_New(AllocCStrDontFree(name))
+	return newModule(mod)
 }
 
 func GetModuleDict() Dict {