update

Author: g.ph

PyBool.go

@@ -0,0 +1,37 @@
+package py3
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"unsafe"
+)
+
+type PyBool struct {
+	PyObject
+}
+
+// PyBoolFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyBoolFromInst(inst uintptr) *PyBool {
+	dl := new(PyBool)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}
+func PyBoolFromObj(obj *PyObject) *PyBool {
+	dl := new(PyBool)
+	dl.PyObject = *obj
+	return dl
+}
+
+func NewPyBoolFromLong(l int64) *PyObject {
+	return PyObjectFromInst(cpy3.PyBool_FromLong(l))
+}
+func NewPyBool(b bool) *PyObject {
+	l := 0
+	if b == true {
+		l = 1
+	}
+	return NewPyBoolFromLong(int64(l))
+}

PyBytes.go

@@ -0,0 +1,25 @@
+package py3
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"unsafe"
+)
+
+type PyBytes struct {
+	PyObject
+}
+
+func PyBytes_FromString(s string) *PyBytes {
+	return PyBytesFromInst(cpy3.PyBytes_FromString(s))
+}
+
+// PyBytesFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyBytesFromInst(inst uintptr) *PyBytes {
+	dl := new(PyBytes)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}

PyClass.go

@@ -0,0 +1,66 @@
+package py3
+
+import (
+	"fmt"
+	"github.com/aadog/py3-go/cpy3"
+	"syscall"
+	"unsafe"
+)
+
+type PyClass struct {
+	PyObject
+}
+
+func (p *PyClass) GetName() string {
+	return p.GetAttrString("__className__").AsUTF8()
+}
+
+// PyClassFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyClassFromInst(inst uintptr) *PyClass {
+	dl := new(PyClass)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}
+func PyClassFromObj(obj *PyObject) *PyClass {
+	dl := new(PyClass)
+	dl.PyObject = *obj
+	return dl
+}
+
+func CreateClass(name string, dict map[string]any) *PyClass {
+	if dict == nil {
+		dict = map[string]any{}
+	}
+	pClassName := GoToPyObject(name)
+	defer pClassName.DecRef()
+	pClassBases := NewPyTuple(0)
+	defer pClassBases.DecRef()
+	pClassDic := GoToPyObject(dict)
+	defer pClassDic.DecRef()
+	pClass := PyObjectFromInst(cpy3.PyObject_CallFunctionObjArgs(cpy3.PyType_Type(), pClassName.Instance(), pClassBases.Instance(), pClassDic.Instance(), 0))
+	pClass.SetAttrString("__className__", NewPyUnicode(name).AsObj())
+
+	fnName := "Call"
+	methodCallDef := &cpy3.PyMethodDef{
+		Ml_name: cpy3.GoStrToCStr(fnName),
+		Ml_meth: syscall.NewCallback(func() uintptr {
+			fmt.Println("call")
+
+			return Py_RETURN_NONE().instance
+		}),
+		Ml_flags: 0,
+		Ml_doc:   cpy3.GoStrToCStr("module call forward"),
+	}
+	PyMethodMap.Store("x", methodCallDef)
+
+	fn := PyObjectFromInst(cpy3.PyCFunction_New(uintptr(unsafe.Pointer(methodCallDef)), cpy3.PyTuple_New(0)))
+	defer fn.DecRef()
+	method := PyObjectFromInst(cpy3.PyInstanceMethod(fn.instance))
+	defer method.DecRef()
+	pClass.SetAttrString(fnName, method)
+	return PyClassFromObj(pClass)
+}

PyConvert.go

@@ -0,0 +1,181 @@
+package py3
+
+import (
+	"reflect"
+)
+
+func GoToPyObject(o interface{}) *PyObject {
+	to := reflect.TypeOf(o)
+	valOf := reflect.ValueOf(o)
+
+	if o == nil {
+		return Py_RETURN_NONE().AsObj()
+	}
+	//*PyObject return
+	if to.AssignableTo(reflect.TypeOf(&PyObject{})) {
+		return o.(*PyObject)
+	}
+	if valOf.CanInt() {
+		return PyLongFromLongLong(valOf.Int()).AsObj()
+	}
+	if valOf.CanUint() {
+		return PyLongFromLongLong(int64(valOf.Uint())).AsObj()
+	}
+	if valOf.CanFloat() {
+		return PyLong_FromDouble(valOf.Float()).AsObj()
+	}
+
+	if to.Kind() == reflect.Bool {
+		return NewPyBool(valOf.Bool())
+	}
+	if to.Kind() == reflect.String {
+		return NewPyUnicode(valOf.String()).AsObj()
+	}
+
+	if to.Kind() == reflect.Slice {
+		l := NewPyList(0)
+		size := valOf.Len()
+		for i := 0; i < size; i++ {
+			item := valOf.Index(i).Interface()
+			o := GoToPyObject(item)
+			defer o.DecRef()
+			l.Append(o)
+		}
+		return l.AsObj()
+	}
+	if to.Kind() == reflect.Map {
+		d := NewPyDict()
+		keys := valOf.MapKeys()
+		for _, key := range keys {
+			k := GoToPyObject(key.Interface())
+			defer k.DecRef()
+			v := GoToPyObject(valOf.MapIndex(key).Interface())
+			defer v.DecRef()
+			d.SetItem(k, v)
+		}
+		return d.AsObj()
+	}
+	return Py_RETURN_NONE().AsObj()
+}
+
+func PyObjectToGo(o *PyObject, to reflect.Type) any {
+	//*PyObject return
+	if to.AssignableTo(reflect.TypeOf(o)) {
+		return o
+	}
+	if to.Kind() == reflect.Int {
+		return int(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Int8 {
+		return int8(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Int16 {
+		return int16(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Int32 {
+		return int32(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Int64 {
+		return int64(o.AsLongLong())
+	}
+
+	if to.Kind() == reflect.Uint {
+		return uint(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Uint8 {
+		return uint8(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Uint16 {
+		return uint16(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Uint32 {
+		return uint32(o.AsLongLong())
+	}
+	if to.Kind() == reflect.Uint64 {
+		return uint64(o.AsLongLong())
+	}
+
+	if to.Kind() == reflect.Uintptr {
+		return uintptr(o.AsLongLong())
+	}
+
+	if to.Kind() == reflect.Bool {
+		return o.AsInt() != 0
+	}
+	if to.Kind() == reflect.String {
+		return o.AsUTF8()
+	}
+	if to.Kind() == reflect.Float32 {
+		return float32(o.AsDouble())
+	}
+	if to.Kind() == reflect.Float64 {
+		return float64(o.AsDouble())
+	}
+	if to.Kind() == reflect.Slice {
+		l := reflect.New(to).Elem()
+		pyL := PyListFromObj(o.AsObj())
+		for i := int64(0); i < pyL.Size(); i++ {
+			l = reflect.Append(l, reflect.ValueOf(PyObjectToGo(pyL.GetItem(i), to.Elem())))
+		}
+		return l.Interface()
+	}
+	if to.Kind() == reflect.Map {
+		l := reflect.MakeMap(to)
+		pyD := PyDictFromObj(o.AsObj())
+		keys := PyListFromObj(pyD.Keys())
+		defer keys.DecRef()
+		for i := int64(0); i < keys.Size(); i++ {
+			k := keys.GetItem(i)
+			goK := PyObjectToGo(k, to.Key())
+			l.SetMapIndex(reflect.ValueOf(goK), reflect.ValueOf(PyObjectToGo(pyD.GetItem(k), to.Elem())))
+		}
+		return l.Interface()
+	}
+	if to.Kind() == reflect.Func {
+		f := reflect.MakeFunc(to, func(args []reflect.Value) (results []reflect.Value) {
+			pyArgs := NewPyTuple(int64(len(args)))
+			for i, arg := range args {
+				pyArgs.SetItem(int64(i), GoToPyObject(arg.Interface()))
+			}
+			rets := o.Call(pyArgs.AsObj(), PyNil)
+			//如果声明函数不需要返回
+			if to.NumOut() == 0 {
+				return nil
+			}
+			tp := rets.Type()
+			defer tp.DecRef()
+
+			goRets := make([]reflect.Value, 0)
+
+			//如果是单个返回
+			if tp.Name() != "tuple" {
+				if to.NumOut() != 1 {
+					k := make([]reflect.Value, 0)
+					for i := 0; i < to.NumOut(); i++ {
+						k = append(k, reflect.ValueOf(reflect.New(to.Out(i)).Elem().Interface()))
+					}
+					PyErr_SetString(PyExc_ValueError(), "返回参数不正确")
+					return k
+				}
+				goRets = append(goRets, reflect.ValueOf(PyObjectToGo(rets, to.Out(0))))
+			} else {
+				tpRets := PyTupleFromObj(rets.AsObj())
+				if int64(to.NumOut()) != tpRets.Size() {
+					k := make([]reflect.Value, 0)
+					for i := 0; i < to.NumOut(); i++ {
+						k = append(k, reflect.ValueOf(reflect.New(to.Out(i)).Elem().Interface()))
+					}
+					PyErr_SetString(PyExc_Exception(), "返回参数不正确")
+					return k
+				}
+				for i := int64(0); i < tpRets.Size(); i++ {
+					goRets = append(goRets, reflect.ValueOf(PyObjectToGo(tpRets.GetItem(i), to.Out(0))))
+				}
+			}
+			return goRets
+		})
+		return f.Interface()
+	}
+
+	return o
+}

PyDict.go

@@ -21,7 +21,7 @@ func (p *PyDict) GetItemString(key string) *PyObject {
 	return PyObjectFromInst(cpy3.PyDict_GetItemString(p.instance, key))
 }
 
-func (p *PyDict) Keys(key *PyObject) *PyObject {
+func (p *PyDict) Keys() *PyObject {
 	return PyObjectFromInst(cpy3.PyDict_Keys(p.instance))
 }
 func (p *PyDict) GetItem(key *PyObject) *PyObject {
@@ -31,6 +31,10 @@ func (p *PyDict) GetItem(key *PyObject) *PyObject {
 func (p *PyDict) SetItemString(key string, val *PyObject) int {
 	return cpy3.PyDict_SetItemString(p.instance, key, val.instance)
 }
+func (p *PyDict) SetItem(key *PyObject, val *PyObject) int {
+	return cpy3.PyDict_SetItem(p.instance, key.instance, val.instance)
+}
+
 func (p *PyDict) Size() int64 {
 	return cpy3.PyDict_Size(p.instance)
 }
@@ -48,6 +52,11 @@ func PyDictFromInst(inst uintptr) *PyDict {
 	dl.ptr = unsafe.Pointer(dl.instance)
 	return dl
 }
+func PyDictFromObj(obj *PyObject) *PyDict {
+	dl := new(PyDict)
+	dl.PyObject = *obj
+	return dl
+}
 
 func NewPyDict() *PyDict {
 	return PyDictFromInst(cpy3.PyDict_New())

PyErr.go

@@ -0,0 +1,14 @@
+package py3
+
+import "github.com/aadog/py3-go/cpy3"
+
+func PyExc_Exception() *PyObject {
+	return PyObjectFromInst(cpy3.PyExc_Exception())
+}
+func PyExc_ValueError() *PyObject {
+	return PyObjectFromInst(cpy3.PyExc_ValueError())
+}
+
+func PyErr_SetString(tp *PyObject, message string) {
+	cpy3.PyErr_SetString(tp.instance, message)
+}

PyFunc.go

@@ -0,0 +1,36 @@
+package py3
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"sync"
+)
+
+var SystemModuleMap = sync.Map{}
+
+func Initialize() {
+	cpy3.Py_Initialize()
+}
+func AddModuleToSystemMap(m *PyModule) {
+	SystemModuleMap.Store(m.GetName(), m)
+}
+func IsInitialized() int {
+	return cpy3.Py_IsInitialized()
+}
+func Finalize() {
+	SystemModuleMap.Range(func(key, value any) bool {
+		SystemModuleMap.Delete(key)
+		m := value.(*PyModule)
+		m.DecRef()
+		return true
+	})
+	cpy3.Py_Finalize()
+}
+func FinalizeEx() int {
+	SystemModuleMap.Range(func(key, value any) bool {
+		SystemModuleMap.Delete(key)
+		m := value.(*PyModule)
+		m.DecRef()
+		return true
+	})
+	return cpy3.Py_FinalizeEx()
+}