py4go/primitive.go

package python

// See:
//   https://docs.python.org/3/c-api/concrete.html

import (
	"fmt"
	"unsafe"
)

/*
#define PY_SSIZE_T_CLEAN
#include <Python.h>
*/
import "C"

func NewPrimitiveReference(value interface{}) (*Reference, error) {
	if value == nil {
		return None, nil
	}

	switch value_ := value.(type) {
	case *Reference:
		return value_, nil
	case bool:
		if value_ {
			return True, nil
		} else {
			return False, nil
		}
	case int64:
		return NewLong(value_)
	case int32:
		return NewLong(int64(value_))
	case int8:
		return NewLong(int64(value_))
	case int:
		return NewLong(int64(value_))
	case float64:
		return NewFloat(value_)
	case float32:
		return NewFloat(float64(value_))
	case string:
		return NewUnicode(value_)
	case []interface{}:
		return NewList(value_...)
	case []byte:
		return NewBytes(value_)
	}
	return nil, fmt.Errorf("unsupported type: %s", value)
}

func (self *Reference) ToInterface(recurse int) (interface{}, error) {
	if self.IsLong() {
		return self.ToInt64()
	}
	if self.IsUnicode() {
		return self.ToString()
	}
	if self.IsBool() {
		return self.ToBool(), nil
	}
	if self.IsNone() {
		return nil, nil
	}
	if self.IsFloat() {
		return self.ToFloat64()
	}
	if self.IsBytes() {
		return self.ToBytes()
	}
	if self.IsByteArray() {
		return self.ByteArrayToBytes()
	}
	if self.IsDict() {
		if recurse <= 0 {
			return nil, fmt.Errorf("reached recursion limit")
		}
		mapValue := make(map[interface{}]interface{})

		dict, err := self.ToMap()
		if err != nil { return mapValue, err }

		errorNum := 0
		for key, val := range dict {
			keyValue, err1 := key.ToInterface(recurse-1)
			valValue, err2 := val.ToInterface(recurse-1)
			key.Release()
			val.Release()
			if err1 == nil && err2 == nil {
				mapValue[keyValue] = valValue
			} else {
				errorNum ++
			}
		}
		if errorNum > 0 {
			return mapValue, fmt.Errorf("failed to convert %d primitives from dictionary", errorNum)
		}
		return mapValue, nil
	}
	if self.IsList() {
		if recurse <= 0 {
			return nil, fmt.Errorf("reached recursion limit")
		}
		pyList, err := self.ToList()
		if err != nil { return nil, err }
		goList := make([]interface{}, len(pyList))

		errorNum := 0
		for i, item := range pyList {
			if goList[i], err = item.ToInterface(recurse-1); err != nil {
				errorNum ++
			}
			item.Release()
		}
		if errorNum > 0 {
			return goList, fmt.Errorf("failed to convert %d primitives from list", errorNum)
		}
		return goList, nil
	}
	return nil, fmt.Errorf("unsupported primitive: %s", self.String())
}


//
// None
//

var None = NewReference(C.Py_None)

//
// Bool
//

var BoolType = NewType(&C.PyBool_Type)

var True = NewReference(C.Py_True)
var False = NewReference(C.Py_False)

func (self *Reference) IsNone() bool {
	return self.Object == C.Py_None
}

func (self *Reference) IsBool() bool {
	return self.Type().IsSubtype(BoolType)
}

func (self *Reference) ToBool() bool {
	switch self.Object {
	case C.Py_True:
		return true
	case C.Py_False:
		return false
	}
	return false
}

//
// Long
//

var LongType = NewType(&C.PyLong_Type)

func NewLong(value int64) (*Reference, error) {
	if long := C.PyLong_FromLong(C.long(value)); long != nil {
		return NewReference(long), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsLong() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_LONG_SUBCLASS)
}

func (self *Reference) ToInt64() (int64, error) {
	if long := C.PyLong_AsLongLong(self.Object); !HasException() {
		return int64(long), nil
	} else {
		return int64(long), GetError()
	}
}

//
// Float
//

var FloatType = NewType(&C.PyFloat_Type)

func NewFloat(value float64) (*Reference, error) {
	if float := C.PyFloat_FromDouble(C.double(value)); float != nil {
		return NewReference(float), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsFloat() bool {
	return self.Type().IsSubtype(FloatType)
}

func (self *Reference) ToFloat64() (float64, error) {
	if double := C.PyFloat_AsDouble(self.Object); !HasException() {
		return float64(double), nil
	} else {
		return 0.0, GetError()
	}
}

//
// Unicode
//

var UnicodeType = NewType(&C.PyUnicode_Type)

func NewUnicode(value string) (*Reference, error) {
	value_ := C.CString(value)
	defer C.free(unsafe.Pointer(value_))

	if unicode := C.PyUnicode_FromString(value_); unicode != nil {
		return NewReference(unicode), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsUnicode() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_UNICODE_SUBCLASS)
}

func (self *Reference) ToString() (string, error) {
	if utf8stringBytes := C.PyUnicode_AsUTF8String(self.Object); utf8stringBytes != nil {
		defer C.Py_DecRef(utf8stringBytes)

		if utf8string := C.PyBytes_AsString(utf8stringBytes); utf8string != nil {
			return C.GoString(utf8string), nil
		} else {
			return "", GetError()
		}
	} else {
		return "", GetError()
	}
}

//
// Tuple
//

var TupleType = NewType(&C.PyTuple_Type)

func NewTuple(items ...interface{}) (*Reference, error) {
	if tuple, err := NewTupleRaw(len(items)); err == nil {
		for index, item := range items {
			if item_, err := NewPrimitiveReference(item); err == nil {
				if err := tuple.SetTupleItem(index, item_); err != nil {
					return nil, err
				}
			} else {
				return nil, err
			}
		}
		return tuple, nil
	} else {
		return nil, GetError()
	}
}

func NewTupleRaw(size int) (*Reference, error) {
	if tuple := C.PyTuple_New(C.long(size)); tuple != nil {
		return NewReference(tuple), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsTuple() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_TUPLE_SUBCLASS)
}

func (self *Reference) SetTupleItem(index int, item *Reference) error {
	if C.PyTuple_SetItem(self.Object, C.long(index), item.Object) == 0 {
		return nil
	} else {
		return GetError()
	}
}

//
// List
//

var ListType = NewType(&C.PyList_Type)

func NewList(items ...interface{}) (*Reference, error) {
	if list, err := NewListRaw(len(items)); err == nil {
		for index, item := range items {
			if item_, err := NewPrimitiveReference(item); err == nil {
				if err := list.SetListItem(index, item_); err != nil {
					return nil, err
				}
			} else {
				return nil, err
			}
		}
		return list, nil
	} else {
		return nil, GetError()
	}
}

func NewListRaw(size int) (*Reference, error) {
	if list := C.PyList_New(C.long(size)); list != nil {
		return NewReference(list), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsList() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_LIST_SUBCLASS)
}

func (self *Reference) SetListItem(index int, item *Reference) error {
	if C.PyList_SetItem(self.Object, C.long(index), item.Object) == 0 {
		return nil
	} else {
		return GetError()
	}
}

func (self *Reference) ToList() ([]*Reference, error) {
	var listLen int
	if listLen = int(C.PyList_Size(self.Object)); HasException() {
		return nil, GetError()
	}
	goList := make([]*Reference, listLen)
	for i := 0; i < listLen; i++ {
		index := C.long(int64(i))
		if item := C.PyList_GetItem(self.Object, index); item != nil {
			goList[i] = NewReference(item)
		}
	}
	return goList, nil
}

func (self *Reference) Iteratable() bool {
	return int(C.PyIter_Check(self.Object)) == 1
}

func (self *Reference) Iterate(next <-chan bool) (<-chan *Reference, error) {
	iterator := C.PyObject_GetIter(self.Object)
	if iterator == nil || HasException() {
		return nil, GetError()
	}
	ch := make(chan *Reference, 1)
	go func() {
		defer close(ch)
		defer C.Py_DecRef(iterator)
		forLoop:
		for ;; {
			if <- next {
				item := C.PyIter_Next(iterator);
				if item == nil { break }
				pyItem := NewReference(item)
				select {
				case ch <- pyItem:
				default:
					pyItem.Release()
					break forLoop
				}
			} else {
				break
			}
		}
	}()
	return ch, nil
}

//
// Dict
//

var DictType = NewType(&C.PyDict_Type)

func NewDict() (*Reference, error) {
	if dict := C.PyDict_New(); dict != nil {
		return NewReference(dict), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsDict() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_DICT_SUBCLASS)
}

func (self *Reference) SetDictItem(key *Reference, value *Reference) error {
	if C.PyDict_SetItem(self.Object, key.Object, value.Object) == 0 {
		return nil
	} else {
		return GetError()
	}
}

func (self *Reference) DictContains(key *Reference) (bool, error) {
	res := C.PyDict_Contains(self.Object, key.Object)
	if res == -1 {
		return false, GetError()
	}
	return res == 1, nil
}

func (self *Reference) DictContainsString(key string) (bool, error) {
	keyObj, err := NewUnicode(key)
	if err != nil {
		return false, err
	}
	defer keyObj.Release()
	res := C.PyDict_Contains(self.Object, keyObj.Object)
	if res == -1 {
		return false, GetError()
	}
	return res == 1, nil
}

func (self *Reference) GetDictItemString(key string) *Reference {
	value_ := C.CString(key)
	defer C.free(unsafe.Pointer(value_))

	if obj := C.PyDict_GetItemString(self.Object, value_); obj != nil {
		return NewReference(obj)
	}
	return nil
}

func (self *Reference) GetDictItem(key *Reference) *Reference {
	if obj := C.PyDict_GetItem(self.Object, key.Object); obj != nil {
		return NewReference(obj)
	}
	return nil
}

func (self *Reference) DeleteDictItem(key *Reference) error {
	if ret := C.PyDict_DelItem(self.Object, key.Object); ret != 0 {
		return GetError()
	}
	return nil
}

func (self *Reference) DeleteDictItemString(key string) error {
	value_ := C.CString(key)
	defer C.free(unsafe.Pointer(value_))

	if ret := C.PyDict_DelItemString(self.Object, value_); ret != 0 {
		return GetError()
	}
	return nil
}

func (self *Reference) ToMap() (map[*Reference]*Reference, error) {
	keys := C.PyDict_Keys(self.Object)
	if HasException() {
		return nil, GetError()
	}
	defer C.Py_DecRef(keys)
	iterator := C.PyObject_GetIter(keys)
	defer C.Py_DecRef(iterator)
	dict := make(map[*Reference]*Reference)
	for {
		key := C.PyIter_Next(iterator);
		if key == nil { break }
		value := C.PyDict_GetItem(self.Object, key)
		if value == nil { continue }
		dict[NewReference(key)] = NewReference(value)
	}
	return dict, nil
}

//
// Set (mutable)
//

var SetType = NewType(&C.PySet_Type)

func NewSet(iterable *Reference) (*Reference, error) {
	if set := C.PySet_New(iterable.Object); set != nil {
		return NewReference(set), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsSet() bool {
	return self.Type().IsSubtype(SetType)
}

//
// Frozen set (immutable)
//

var FrozenSetType = NewType(&C.PyFrozenSet_Type)

func NewFrozenSet(iterable *Reference) (*Reference, error) {
	if frozenSet := C.PyFrozenSet_New(iterable.Object); frozenSet != nil {
		return NewReference(frozenSet), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsFrozenSet() bool {
	return self.Type().IsSubtype(FrozenSetType)
}

//
// Bytes (immutable)
//

var BytesType = NewType(&C.PyBytes_Type)

func NewBytes(value []byte) (*Reference, error) {
	size := len(value)
	value_ := C.CBytes(value)
	defer C.free(value_) // TODO: check this!

	if bytes := C.PyBytes_FromStringAndSize((*C.char)(value_), C.long(size)); bytes != nil {
		return NewReference(bytes), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsBytes() bool {
	// More efficient to use the flag
	return self.Type().HasFlag(C.Py_TPFLAGS_BYTES_SUBCLASS)
}

func (self *Reference) ToBytes() ([]byte, error) {
	if pointer, size, err := self.AccessBytes(); err == nil {
		return C.GoBytes(pointer, C.int(size)), nil
	} else {
		return nil, err
	}
}

func (self *Reference) AccessBytes() (unsafe.Pointer, int, error) {
	if string_ := C.PyBytes_AsString(self.Object); string_ != nil {
		size := C.PyBytes_Size(self.Object)
		return unsafe.Pointer(string_), int(size), nil
	} else {
		return nil, 0, GetError()
	}
}

//
// Byte array (mutable)
//

var ByteArrayType = NewType(&C.PyByteArray_Type)

func NewByteArray(value []byte) (*Reference, error) {
	size := len(value)
	value_ := C.CBytes(value)
	defer C.free(value_) // TODO: check this!

	if byteArray := C.PyByteArray_FromStringAndSize((*C.char)(value_), C.long(size)); byteArray != nil {
		return NewReference(byteArray), nil
	} else {
		return nil, GetError()
	}
}

func (self *Reference) IsByteArray() bool {
	return self.Type().IsSubtype(ByteArrayType)
}

func (self *Reference) ByteArrayToBytes() ([]byte, error) {
	if pointer, size, err := self.AccessByteArray(); err == nil {
		return C.GoBytes(pointer, C.int(size)), nil
	} else {
		return nil, err
	}
}

func (self *Reference) AccessByteArray() (unsafe.Pointer, int, error) {
	if string_ := C.PyByteArray_AsString(self.Object); string_ != nil {
		size := C.PyByteArray_Size(self.Object)
		return unsafe.Pointer(string_), int(size), nil
	} else {
		return nil, 0, GetError()
	}
}

//
//  Object
//

//var ObjectType = NewType(&C.PyObject_Type)
//
//func (self *Reference) IsObject() bool {
//	return self.Type().IsSubtype(ObjectType)
//}

func (self *Reference) IsInstance(cls *Reference) (bool, error) {
	inst := int64(C.PyObject_IsInstance(self.Object, cls.Object))
	if HasException() {
		return false, GetError()
	}
	return inst == 1, nil
}