6 files changed, 663 insertions, 233 deletions

diff --git a/source/blender/python/generic/bgl.c b/source/blender/python/generic/bgl.c
index 3ea10228ad4..a0185b0f4fa 100644
--- a/source/blender/python/generic/bgl.c
+++ b/source/blender/python/generic/bgl.c
@@ -472,6 +472,49 @@ int BGL_typeSize(int type)
 	return -1;
 }
 
+static int gl_buffer_type_from_py_format_char(char *typestr)
+{
+	if (ELEM(typestr[0], '<', '>', '|')) {
+		typestr += 1;
+	}
+	char format = typestr[0];
+	char byte_num = typestr[1];
+
+	switch (format) {
+		case 't':
+		case 'b':
+		case 'h':
+			if (!byte_num) return GL_BYTE;
+			ATTR_FALLTHROUGH;
+		case 'i':
+			if (!byte_num) return GL_SHORT;
+			ATTR_FALLTHROUGH;
+		case 'l':
+			if (!byte_num || byte_num == '4') return GL_INT;
+			if (byte_num == '1') return GL_BYTE;
+			if (byte_num == '2') return GL_SHORT;
+			break;
+		case 'f':
+			if (!byte_num) return GL_FLOAT;
+			ATTR_FALLTHROUGH;
+		case 'd':
+			if (!byte_num || byte_num == '8') return GL_DOUBLE;
+			if (byte_num == '4') return GL_FLOAT;
+			break;
+	}
+	return -1; /* UNKNOWN */
+}
+
+static bool compare_dimensions(int ndim, int *dim1, Py_ssize_t *dim2)
+{
+	for (int i = 0; i < ndim; i++) {
+		if (dim1[i] != dim2[i]) {
+			return false;
+		}
+	}
+	return true;
+}
+
 /** \} */
 
 
@@ -630,6 +673,22 @@ PyTypeObject BGL_bufferType = {
 	NULL                        /*tp_del*/
 };
 
+
+static Buffer *BGL_MakeBuffer_FromData(PyObject *parent, int type, int ndimensions, int *dimensions, void *buf)
+{
+	Buffer *buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
+
+	Py_XINCREF(parent);
+	buffer->parent = parent;
+	buffer->ndimensions = ndimensions;
+	buffer->dimensions = MEM_mallocN(ndimensions * sizeof(int), "Buffer dimensions");
+	memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int));
+	buffer->type = type;
+	buffer->buf.asvoid = buf;
+
+	return buffer;
+}
+
 /**
  * Create a buffer object
  *
@@ -641,30 +700,21 @@ Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuf
 {
 	Buffer *buffer;
 	void *buf = NULL;
-	int i, size, length;
+	int i, size = BGL_typeSize(type);
 
-	length = 1;
 	for (i = 0; i < ndimensions; i++) {
-		length *= dimensions[i];
+		size *= dimensions[i];
 	}
 
-	size = BGL_typeSize(type);
+	buf = MEM_mallocN(size, "Buffer buffer");
 
-	buf = MEM_mallocN(length * size, "Buffer buffer");
-
-	buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
-	buffer->parent = NULL;
-	buffer->ndimensions = ndimensions;
-	buffer->dimensions = MEM_mallocN(ndimensions * sizeof(int), "Buffer dimensions");
-	memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int));
-	buffer->type = type;
-	buffer->buf.asvoid = buf;
+	buffer = BGL_MakeBuffer_FromData(NULL, type, ndimensions, dimensions, buf);
 
 	if (initbuffer) {
-		memcpy(buffer->buf.asvoid, initbuffer, length * size);
+		memcpy(buffer->buf.asvoid, initbuffer, size);
 	}
 	else {
-		memset(buffer->buf.asvoid, 0, length * size);
+		memset(buffer->buf.asvoid, 0, size);
 	}
 	return buffer;
 }
@@ -674,7 +724,7 @@ Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuf
 static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
 {
 	PyObject *length_ob = NULL, *init = NULL;
-	Buffer *buffer;
+	Buffer *buffer = NULL;
 	int dimensions[MAX_DIMENSIONS];
 
 	int type;
@@ -739,9 +789,32 @@ static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject
 		return NULL;
 	}
 
-	buffer = BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
-	if (init && ndimensions) {
-		if (Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
+	if (init && PyObject_CheckBuffer(init)) {
+		Py_buffer pybuffer;
+
+		if (PyObject_GetBuffer(init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) {
+			/* PyObject_GetBuffer raise a PyExc_BufferError */
+			return NULL;
+		}
+
+		if (type != gl_buffer_type_from_py_format_char(pybuffer.format)) {
+			PyErr_Format(PyExc_TypeError,
+			             "`GL_TYPE` and `typestr` of object with buffer interface do not match. '%s'", pybuffer.format);
+		}
+		else if (ndimensions != pybuffer.ndim ||
+		         !compare_dimensions(ndimensions, dimensions, pybuffer.shape))
+		{
+			PyErr_Format(PyExc_TypeError, "array size does not match");
+		}
+		else {
+			buffer = BGL_MakeBuffer_FromData(init, type, pybuffer.ndim, dimensions, pybuffer.buf);
+		}
+
+		PyBuffer_Release(&pybuffer);
+	}
+	else {
+		buffer = BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
+		if (init && Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
 			Py_DECREF(buffer);
 			return NULL;
 		}
@@ -774,27 +847,17 @@ static PyObject *Buffer_item(Buffer *self, int i)
 		}
 	}
 	else {
-		Buffer *newbuf;
-		int j, length, size;
+		int j, offset = i * BGL_typeSize(self->type);
 
-		length = 1;
 		for (j = 1; j < self->ndimensions; j++) {
-			length *= self->dimensions[j];
+			offset *= self->dimensions[j];
 		}
-		size = BGL_typeSize(self->type);
-
-		newbuf = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
-
-		Py_INCREF(self);
-		newbuf->parent = (PyObject *)self;
-
-		newbuf->ndimensions = self->ndimensions - 1;
-		newbuf->type = self->type;
-		newbuf->buf.asvoid = self->buf.asbyte + i * length * size;
-		newbuf->dimensions = MEM_mallocN(newbuf->ndimensions * sizeof(int), "Buffer dimensions");
-		memcpy(newbuf->dimensions, self->dimensions + 1, newbuf->ndimensions * sizeof(int));
 
-		return (PyObject *)newbuf;
+		return (PyObject *)BGL_MakeBuffer_FromData(
+		        (PyObject *)self, self->type,
+		        self->ndimensions - 1,
+		        self->dimensions + 1,
+		        self->buf.asbyte + offset);
 	}
 
 	return NULL;
diff --git a/source/blender/python/generic/bpy_internal_import.c b/source/blender/python/generic/bpy_internal_import.c
index ed2752d8372..ffac09efdde 100644
--- a/source/blender/python/generic/bpy_internal_import.c
+++ b/source/blender/python/generic/bpy_internal_import.c
@@ -248,8 +248,17 @@ PyObject *bpy_text_reimport(PyObject *module, int *found)
 	if ((name = PyModule_GetName(module)) == NULL)
 		return NULL;
 
-	if ((filepath = (char *)PyModule_GetFilename(module)) == NULL)
-		return NULL;
+	{
+		PyObject *module_file = PyModule_GetFilenameObject(module);
+		if (module_file == NULL) {
+			return NULL;
+		}
+		filepath = _PyUnicode_AsString(module_file);
+		Py_DECREF(module_file);
+		if (filepath == NULL) {
+			return NULL;
+		}
+	}
 
 	/* look up the text object */
 	text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
@@ -276,13 +285,13 @@ static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject
 	int found = 0;
 	PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
 	int level = 0; /* relative imports */
-	
 	PyObject *newmodule;
-	//PyObject_Print(args, stderr, 0);
-	static const char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", NULL};
-	
-	if (!PyArg_ParseTupleAndKeywords(args, kw, "s|OOOi:bpy_import_meth", (char **)kwlist,
-	                                 &name, &globals, &locals, &fromlist, &level))
+
+	static const char *_keywords[] = {"name", "globals", "locals", "fromlist", "level", NULL};
+	static _PyArg_Parser _parser = {"s|OOOi:bpy_import_meth", _keywords, 0};
+	if (!_PyArg_ParseTupleAndKeywordsFast(
+	        args, kw, &_parser,
+	        &name, &globals, &locals, &fromlist, &level))
 	{
 		return NULL;
 	}
diff --git a/source/blender/python/generic/idprop_py_api.c b/source/blender/python/generic/idprop_py_api.c
index 2e15b7b1413..1153e0176df 100644
--- a/source/blender/python/generic/idprop_py_api.c
+++ b/source/blender/python/generic/idprop_py_api.c
@@ -43,6 +43,9 @@
 
 #include "python_utildefines.h"
 
+extern bool pyrna_id_FromPyObject(PyObject *obj, ID **id);
+extern PyObject *pyrna_id_CreatePyObject(ID *id);
+extern bool pyrna_id_CheckPyObject(PyObject *obj);
 
 /*********************** ID Property Main Wrapper Stuff ***************/
 
@@ -88,6 +91,11 @@ static PyObject *idprop_py_from_idp_group(ID *id, IDProperty *prop, IDProperty *
 	return (PyObject *)group;
 }
 
+static PyObject *idprop_py_from_idp_id(IDProperty *prop)
+{
+	return pyrna_id_CreatePyObject(prop->data.pointer);
+}
+
 static PyObject *idprop_py_from_idp_array(ID *id, IDProperty *prop)
 {
 	BPy_IDProperty *array = PyObject_New(BPy_IDProperty, &BPy_IDArray_Type);
@@ -148,6 +156,7 @@ PyObject *BPy_IDGroup_WrapData(ID *id, IDProperty *prop, IDProperty *parent)
 		case IDP_GROUP:    return idprop_py_from_idp_group(id, prop, parent);
 		case IDP_ARRAY:    return idprop_py_from_idp_array(id, prop);
 		case IDP_IDPARRAY: return idprop_py_from_idp_idparray(id, prop); /* this could be better a internal type */
+		case IDP_ID:       return idprop_py_from_idp_id(prop);
 		default: Py_RETURN_NONE;
 	}
 }
@@ -335,19 +344,9 @@ static char idp_sequence_type(PyObject *seq_fast)
 	return type;
 }
 
-/**
- * \note group can be a pointer array or a group.
- * assume we already checked key is a string.
- *
- * \return success.
- */
-bool BPy_IDProperty_Map_ValidateAndCreate(PyObject *name_obj, IDProperty *group, PyObject *ob)
+static const char *idp_try_read_name(PyObject *name_obj)
 {
-	IDProperty *prop = NULL;
-	IDPropertyTemplate val = {0};
-
-	const char *name;
-
+	const char *name = NULL;
 	if (name_obj) {
 		Py_ssize_t name_size;
 		name = _PyUnicode_AsStringAndSize(name_obj, &name_size);
@@ -356,168 +355,307 @@ bool BPy_IDProperty_Map_ValidateAndCreate(PyObject *name_obj, IDProperty *group,
 			PyErr_Format(PyExc_KeyError,
 			             "invalid id-property key, expected a string, not a %.200s",
 			             Py_TYPE(name_obj)->tp_name);
-			return false;
+			return NULL;
 		}
 
 		if (name_size > MAX_IDPROP_NAME) {
 			PyErr_SetString(PyExc_KeyError, "the length of IDProperty names is limited to 63 characters");
-			return false;
+			return NULL;
 		}
 	}
 	else {
 		name = "";
 	}
+	return name;
+}
 
-	if (PyFloat_Check(ob)) {
-		val.d = PyFloat_AsDouble(ob);
-		prop = IDP_New(IDP_DOUBLE, &val, name);
-	}
-	else if (PyLong_Check(ob)) {
-		val.i = _PyLong_AsInt(ob);
-		if (val.i == -1 && PyErr_Occurred()) {
-			return false;
-		}
-		prop = IDP_New(IDP_INT, &val, name);
+/* -------------------------------------------------------------------------- */
+
+/**
+ * The 'idp_from_Py*' functions expect that the input type has been checked before
+ * and return NULL if the IDProperty can't be created.
+ */
+
+static IDProperty *idp_from_PyFloat(const char *name, PyObject *ob)
+{
+	IDPropertyTemplate val = {0};
+	val.d = PyFloat_AsDouble(ob);
+	return IDP_New(IDP_DOUBLE, &val, name);
+}
+
+static IDProperty *idp_from_PyLong(const char *name, PyObject *ob)
+{
+	IDPropertyTemplate val = {0};
+	val.i = PyC_Long_AsI32(ob);
+	if (val.i == -1 && PyErr_Occurred()) {
+		return NULL;
 	}
-	else if (PyUnicode_Check(ob)) {
+	return IDP_New(IDP_INT, &val, name);
+}
+
+static IDProperty *idp_from_PyUnicode(const char *name, PyObject *ob)
+{
+	IDProperty *prop;
+	IDPropertyTemplate val = {0};
 #ifdef USE_STRING_COERCE
-		Py_ssize_t value_size;
-		PyObject *value_coerce = NULL;
-		val.string.str = PyC_UnicodeAsByteAndSize(ob, &value_size, &value_coerce);
-		val.string.len = (int)value_size + 1;
-		val.string.subtype = IDP_STRING_SUB_UTF8;
-		prop = IDP_New(IDP_STRING, &val, name);
-		Py_XDECREF(value_coerce);
+	Py_ssize_t value_size;
+	PyObject *value_coerce = NULL;
+	val.string.str = PyC_UnicodeAsByteAndSize(ob, &value_size, &value_coerce);
+	val.string.len = (int)value_size + 1;
+	val.string.subtype = IDP_STRING_SUB_UTF8;
+	prop = IDP_New(IDP_STRING, &val, name);
+	Py_XDECREF(value_coerce);
 #else
-		val.str = _PyUnicode_AsString(ob);
-		prop = IDP_New(IDP_STRING, val, name);
+	val.str = _PyUnicode_AsString(ob);
+	prop = IDP_New(IDP_STRING, val, name);
 #endif
-	}
-	else if (PyBytes_Check(ob)) {
-		val.string.str = PyBytes_AS_STRING(ob);
-		val.string.len = PyBytes_GET_SIZE(ob);
-		val.string.subtype = IDP_STRING_SUB_BYTE;
+	return prop;
+}
+
+static IDProperty *idp_from_PyBytes(const char *name, PyObject *ob)
+{
+	IDPropertyTemplate val = {0};
+	val.string.str = PyBytes_AS_STRING(ob);
+	val.string.len = PyBytes_GET_SIZE(ob);
+	val.string.subtype = IDP_STRING_SUB_BYTE;
+	return IDP_New(IDP_STRING, &val, name);
+}
 
-		prop = IDP_New(IDP_STRING, &val, name);
-		//prop = IDP_NewString(PyBytes_AS_STRING(ob), name, PyBytes_GET_SIZE(ob));
-		//prop->subtype = IDP_STRING_SUB_BYTE;
+static int idp_array_type_from_format_char(char format)
+{
+	if (format == 'i') return IDP_INT;
+	if (format == 'f') return IDP_FLOAT;
+	if (format == 'd') return IDP_DOUBLE;
+	return -1;
+}
+
+static const char *idp_format_from_array_type(int type)
+{
+	if (type == IDP_INT) return "i";
+	if (type == IDP_FLOAT) return "f";
+	if (type == IDP_DOUBLE) return "d";
+	return NULL;
+}
+
+static IDProperty *idp_from_PySequence_Buffer(const char *name, Py_buffer *buffer)
+{
+	IDProperty *prop;
+	IDPropertyTemplate val = {0};
+
+	int format = idp_array_type_from_format_char(*buffer->format);
+	if (format == -1) {
+		/* should never happen as the type has been checked before */
+		return NULL;
 	}
-	else if (PySequence_Check(ob)) {
-		PyObject *ob_seq_fast;
-		PyObject **ob_seq_fast_items;
-		PyObject *item;
-		int i;
+	else {
+		val.array.type = format;
+		val.array.len = buffer->len / buffer->itemsize;
+	}
+	prop = IDP_New(IDP_ARRAY, &val, name);
+	memcpy(IDP_Array(prop), buffer->buf, buffer->len);
+	return prop;
+}
 
-		if (!(ob_seq_fast = PySequence_Fast(ob, "py -> idprop"))) {
-			return false;
-		}
+static IDProperty *idp_from_PySequence_Fast(const char *name, PyObject *ob)
+{
+	IDProperty *prop;
+	IDPropertyTemplate val = {0};
 
-		ob_seq_fast_items = PySequence_Fast_ITEMS(ob_seq_fast);
+	PyObject **ob_seq_fast_items;
+	PyObject *item;
+	int i;
 
-		if ((val.array.type = idp_sequence_type(ob_seq_fast)) == (char)-1) {
-			Py_DECREF(ob_seq_fast);
-			PyErr_SetString(PyExc_TypeError, "only floats, ints and dicts are allowed in ID property arrays");
-			return false;
-		}
+	ob_seq_fast_items = PySequence_Fast_ITEMS(ob);
 
-		/* validate sequence and derive type.
-		 * we assume IDP_INT unless we hit a float
-		 * number; then we assume it's */
+	if ((val.array.type = idp_sequence_type(ob)) == (char)-1) {
+		PyErr_SetString(PyExc_TypeError, "only floats, ints and dicts are allowed in ID property arrays");
+		return NULL;
+	}
 
-		val.array.len = PySequence_Fast_GET_SIZE(ob_seq_fast);
+	/* validate sequence and derive type.
+	 * we assume IDP_INT unless we hit a float
+	 * number; then we assume it's */
 
-		switch (val.array.type) {
-			case IDP_DOUBLE:
-			{
-				double *prop_data;
-
-				prop = IDP_New(IDP_ARRAY, &val, name);
-				prop_data = IDP_Array(prop);
-				for (i = 0; i < val.array.len; i++) {
-					item = ob_seq_fast_items[i];
-					if (((prop_data[i] = PyFloat_AsDouble(item)) == -1.0) && PyErr_Occurred()) {
-						Py_DECREF(ob_seq_fast);
-						return false;
-					}
+	val.array.len = PySequence_Fast_GET_SIZE(ob);
+
+	switch (val.array.type) {
+		case IDP_DOUBLE:
+		{
+			double *prop_data;
+			prop = IDP_New(IDP_ARRAY, &val, name);
+			prop_data = IDP_Array(prop);
+			for (i = 0; i < val.array.len; i++) {
+				item = ob_seq_fast_items[i];
+				if (((prop_data[i] = PyFloat_AsDouble(item)) == -1.0) && PyErr_Occurred()) {
+					return NULL;
 				}
-				break;
 			}
-			case IDP_INT:
-			{
-				int *prop_data;
-				prop = IDP_New(IDP_ARRAY, &val, name);
-				prop_data = IDP_Array(prop);
-				for (i = 0; i < val.array.len; i++) {
-					item = ob_seq_fast_items[i];
-					if (((prop_data[i] = _PyLong_AsInt(item)) == -1) && PyErr_Occurred()) {
-						Py_DECREF(ob_seq_fast);
-						return false;
-					}
+			break;
+		}
+		case IDP_INT:
+		{
+			int *prop_data;
+			prop = IDP_New(IDP_ARRAY, &val, name);
+			prop_data = IDP_Array(prop);
+			for (i = 0; i < val.array.len; i++) {
+				item = ob_seq_fast_items[i];
+				if (((prop_data[i] = PyC_Long_AsI32(item)) == -1) && PyErr_Occurred()) {
+					return NULL;
 				}
-				break;
 			}
-			case IDP_IDPARRAY:
-			{
-				prop = IDP_NewIDPArray(name);
-				for (i = 0; i < val.array.len; i++) {
-					item = ob_seq_fast_items[i];
-
-					if (BPy_IDProperty_Map_ValidateAndCreate(NULL, prop, item) == false) {
-						Py_DECREF(ob_seq_fast);
-						return false;
-					}
+			break;
+		}
+		case IDP_IDPARRAY:
+		{
+			prop = IDP_NewIDPArray(name);
+			for (i = 0; i < val.array.len; i++) {
+				item = ob_seq_fast_items[i];
+				if (BPy_IDProperty_Map_ValidateAndCreate(NULL, prop, item) == false) {
+					return NULL;
 				}
-				break;
 			}
-			default:
-				/* should never happen */
-				Py_DECREF(ob_seq_fast);
-				PyErr_SetString(PyExc_RuntimeError, "internal error with idp array.type");
-				return false;
+			break;
 		}
+		default:
+			/* should never happen */
+			PyErr_SetString(PyExc_RuntimeError, "internal error with idp array.type");
+			return NULL;
+	}
+	return prop;
+}
 
-		Py_DECREF(ob_seq_fast);
+
+static IDProperty *idp_from_PySequence(const char *name, PyObject *ob)
+{
+	Py_buffer buffer;
+	bool use_buffer = false;
+
+	if (PyObject_CheckBuffer(ob)) {
+		PyObject_GetBuffer(ob, &buffer, PyBUF_SIMPLE | PyBUF_FORMAT);
+		char format = *buffer.format;
+		if (ELEM(format, 'i', 'f', 'd')) {
+			use_buffer = true;
+		}
+		else {
+			PyBuffer_Release(&buffer);
+		}
 	}
-	else if (PyMapping_Check(ob)) {
-		PyObject *keys, *vals, *key, *pval;
-		int i, len;
-		/*yay! we get into recursive stuff now!*/
-		keys = PyMapping_Keys(ob);
-		vals = PyMapping_Values(ob);
-
-		/* we allocate the group first; if we hit any invalid data,
-		 * we can delete it easily enough.*/
-		prop = IDP_New(IDP_GROUP, &val, name);
-		len = PyMapping_Length(ob);
-		for (i = 0; i < len; i++) {
-			key = PySequence_GetItem(keys, i);
-			pval = PySequence_GetItem(vals, i);
-			if (BPy_IDProperty_Map_ValidateAndCreate(key, prop, pval) == false) {
-				IDP_FreeProperty(prop);
-				MEM_freeN(prop);
-				Py_XDECREF(keys);
-				Py_XDECREF(vals);
-				Py_XDECREF(key);
-				Py_XDECREF(pval);
-				/* error is already set */
-				return false;
-			}
+
+	if (use_buffer) {
+		IDProperty *prop = idp_from_PySequence_Buffer(name, &buffer);
+		PyBuffer_Release(&buffer);
+		return prop;
+	}
+	else {
+		PyObject *ob_seq_fast = PySequence_Fast(ob, "py -> idprop");
+		if (ob_seq_fast != NULL) {
+			IDProperty *prop = idp_from_PySequence_Fast(name, ob_seq_fast);
+			Py_DECREF(ob_seq_fast);
+			return prop;
+		}
+		else {
+			return NULL;
+		}
+	}
+}
+
+static IDProperty *idp_from_PyMapping(const char *name, PyObject *ob)
+{
+	IDProperty *prop;
+	IDPropertyTemplate val = {0};
+
+	PyObject *keys, *vals, *key, *pval;
+	int i, len;
+	/* yay! we get into recursive stuff now! */
+	keys = PyMapping_Keys(ob);
+	vals = PyMapping_Values(ob);
+
+	/* we allocate the group first; if we hit any invalid data,
+	 * we can delete it easily enough.*/
+	prop = IDP_New(IDP_GROUP, &val, name);
+	len = PyMapping_Length(ob);
+	for (i = 0; i < len; i++) {
+		key = PySequence_GetItem(keys, i);
+		pval = PySequence_GetItem(vals, i);
+		if (BPy_IDProperty_Map_ValidateAndCreate(key, prop, pval) == false) {
+			IDP_FreeProperty(prop);
+			MEM_freeN(prop);
+			Py_XDECREF(keys);
+			Py_XDECREF(vals);
 			Py_XDECREF(key);
 			Py_XDECREF(pval);
+			/* error is already set */
+			return NULL;
 		}
-		Py_XDECREF(keys);
-		Py_XDECREF(vals);
+		Py_XDECREF(key);
+		Py_XDECREF(pval);
+	}
+	Py_XDECREF(keys);
+	Py_XDECREF(vals);
+	return prop;
+}
+
+static IDProperty *idp_from_DatablockPointer(const char *name, PyObject *ob, IDPropertyTemplate *val)
+{
+	pyrna_id_FromPyObject(ob, &val->id);
+	return IDP_New(IDP_ID, val, name);
+}
+
+static IDProperty *idp_from_PyObject(PyObject *name_obj, PyObject *ob)
+{
+	IDPropertyTemplate val = {0};
+	const char *name = idp_try_read_name(name_obj);
+	if (name == NULL) {
+		return NULL;
+	}
+
+	if (PyFloat_Check(ob)) {
+		return idp_from_PyFloat(name, ob);
+	}
+	else if (PyLong_Check(ob)) {
+		return idp_from_PyLong(name, ob);
+	}
+	else if (PyUnicode_Check(ob)) {
+		return idp_from_PyUnicode(name, ob);
+	}
+	else if (PyBytes_Check(ob)) {
+		return idp_from_PyBytes(name, ob);
+	}
+	else if (PySequence_Check(ob)) {
+		return idp_from_PySequence(name, ob);
+	}
+	else if (ob == Py_None || pyrna_id_CheckPyObject(ob)) {
+		return idp_from_DatablockPointer(name, ob, &val);
+	}
+	else if (PyMapping_Check(ob)) {
+		return idp_from_PyMapping(name, ob);
 	}
 	else {
 		PyErr_Format(PyExc_TypeError,
 		             "invalid id-property type %.200s not supported",
 		             Py_TYPE(ob)->tp_name);
+		return NULL;
+	}
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * \note group can be a pointer array or a group.
+ * assume we already checked key is a string.
+ *
+ * \return success.
+ */
+bool BPy_IDProperty_Map_ValidateAndCreate(PyObject *name_obj, IDProperty *group, PyObject *ob)
+{
+	IDProperty *prop = idp_from_PyObject(name_obj, ob);
+	if (prop == NULL) {
 		return false;
 	}
 
 	if (group->type == IDP_IDPARRAY) {
 		IDP_AppendArray(group, prop);
-		// IDP_FreeProperty(item);  /* IDP_AppendArray does a shallow copy (memcpy), only free memory */
+		/* IDP_AppendArray does a shallow copy (memcpy), only free memory */
 		MEM_freeN(prop);
 	}
 	else {
@@ -613,6 +751,8 @@ static PyObject *BPy_IDGroup_MapDataToPy(IDProperty *prop)
 			return idprop_py_from_idp_float(prop);
 		case IDP_DOUBLE:
 			return idprop_py_from_idp_double(prop);
+		case IDP_ID:
+			return idprop_py_from_idp_id(prop);
 		case IDP_ARRAY:
 		{
 			PyObject *seq = PyList_New(prop->len);
@@ -1197,7 +1337,7 @@ static int BPy_IDArray_SetItem(BPy_IDArray *self, int index, PyObject *value)
 		}
 		case IDP_INT:
 		{
-			const int i = _PyLong_AsInt(value);
+			const int i = PyC_Long_AsI32(value);
 			if (i == -1 && PyErr_Occurred()) {
 				return -1;
 			}
@@ -1371,6 +1511,44 @@ static PyMappingMethods BPy_IDArray_AsMapping = {
 	(objobjargproc)BPy_IDArray_ass_subscript
 };
 
+static int itemsize_by_idarray_type(int array_type)
+{
+	if (array_type == IDP_INT) return sizeof(int);
+	if (array_type == IDP_FLOAT) return sizeof(float);
+	if (array_type == IDP_DOUBLE) return sizeof(double);
+	return -1;  /* should never happen */
+}
+
+static int BPy_IDArray_getbuffer(BPy_IDArray *self, Py_buffer *view, int flags)
+{
+	IDProperty *prop = self->prop;
+	int itemsize = itemsize_by_idarray_type(prop->subtype);
+	int length = itemsize * prop->len;
+
+	if (PyBuffer_FillInfo(view, (PyObject *)self, IDP_Array(prop), length, false, flags) == -1) {
+		return -1;
+	}
+
+	view->itemsize = itemsize;
+	view->format = (char *)idp_format_from_array_type(prop->subtype);
+
+	Py_ssize_t *shape = MEM_mallocN(sizeof(Py_ssize_t), __func__);
+	shape[0] = prop->len;
+	view->shape = shape;
+
+	return 0;
+}
+
+static void BPy_IDArray_releasebuffer(BPy_IDArray *UNUSED(self), Py_buffer *view)
+{
+	MEM_freeN(view->shape);
+}
+
+static PyBufferProcs BPy_IDArray_Buffer = {
+	(getbufferproc)BPy_IDArray_getbuffer,
+	(releasebufferproc)BPy_IDArray_releasebuffer,
+};
+
 
 PyTypeObject BPy_IDArray_Type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
@@ -1403,7 +1581,7 @@ PyTypeObject BPy_IDArray_Type = {
 	NULL,                       /* setattrofunc tp_setattro; */
 
 	/* Functions to access object as input/output buffer */
-	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+	&BPy_IDArray_Buffer,        /* PyBufferProcs *tp_as_buffer; */
 
 	/*** Flags to define presence of optional/expanded features ***/
 	Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
diff --git a/source/blender/python/generic/py_capi_utils.c b/source/blender/python/generic/py_capi_utils.c
index 7b2d58a1268..d49f9514b8c 100644
--- a/source/blender/python/generic/py_capi_utils.c
+++ b/source/blender/python/generic/py_capi_utils.c
@@ -85,7 +85,7 @@ int PyC_AsArray_FAST(
 		/* could use is_double for 'long int' but no use now */
 		int *array_int = array;
 		for (i = 0; i < length; i++) {
-			array_int[i] = PyLong_AsLong(value_fast_items[i]);
+			array_int[i] = PyC_Long_AsI32(value_fast_items[i]);
 		}
 	}
 	else if (type == &PyBool_Type) {
@@ -127,54 +127,52 @@ int PyC_AsArray(
 	return ret;
 }
 
+/* -------------------------------------------------------------------- */
+/** \name Typed Tuple Packing
+ *
+ * \note See #PyC_Tuple_Pack_* macros that take multiple arguments.
+ *
+ * \{ */
+
 /* array utility function */
-PyObject *PyC_FromArray(const void *array, int length, const PyTypeObject *type,
-                        const bool is_double, const char *error_prefix)
+PyObject *PyC_Tuple_PackArray_F32(const float *array, uint len)
 {
-	PyObject *tuple;
-	int i;
-
-	tuple = PyTuple_New(length);
-
-	/* for each type */
-	if (type == &PyFloat_Type) {
-		if (is_double) {
-			const double *array_double = array;
-			for (i = 0; i < length; ++i) {
-				PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(array_double[i]));
-			}
-		}
-		else {
-			const float *array_float = array;
-			for (i = 0; i < length; ++i) {
-				PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(array_float[i]));
-			}
-		}
-	}
-	else if (type == &PyLong_Type) {
-		/* could use is_double for 'long int' but no use now */
-		const int *array_int = array;
-		for (i = 0; i < length; ++i) {
-			PyTuple_SET_ITEM(tuple, i, PyLong_FromLong(array_int[i]));
-		}
+	PyObject *tuple = PyTuple_New(len);
+	for (uint i = 0; i < len; i++) {
+		PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(array[i]));
 	}
-	else if (type == &PyBool_Type) {
-		const int *array_bool = array;
-		for (i = 0; i < length; ++i) {
-			PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(array_bool[i]));
-		}
+	return tuple;
+}
+
+PyObject *PyC_Tuple_PackArray_I32(const int *array, uint len)
+{
+	PyObject *tuple = PyTuple_New(len);
+	for (uint i = 0; i < len; i++) {
+		PyTuple_SET_ITEM(tuple, i, PyLong_FromLong(array[i]));
 	}
-	else {
-		Py_DECREF(tuple);
-		PyErr_Format(PyExc_TypeError,
-		             "%s: internal error %s is invalid",
-		             error_prefix, type->tp_name);
-		return NULL;
+	return tuple;
+}
+
+PyObject *PyC_Tuple_PackArray_I32FromBool(const int *array, uint len)
+{
+	PyObject *tuple = PyTuple_New(len);
+	for (uint i = 0; i < len; i++) {
+		PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(array[i]));
 	}
+	return tuple;
+}
 
+PyObject *PyC_Tuple_PackArray_Bool(const bool *array, uint len)
+{
+	PyObject *tuple = PyTuple_New(len);
+	for (uint i = 0; i < len; i++) {
+		PyTuple_SET_ITEM(tuple, i, PyBool_FromLong(array[i]));
+	}
 	return tuple;
 }
 
+/** \} */
+
 /**
  * Caller needs to ensure tuple is uninitialized.
  * Handy for filling a tuple with None for eg.
@@ -203,6 +201,8 @@ void PyC_List_Fill(PyObject *list, PyObject *value)
 
 /**
  * Use with PyArg_ParseTuple's "O&" formatting.
+ *
+ * \see #PyC_Long_AsBool for a similar function to use outside of argument parsing.
  */
 int PyC_ParseBool(PyObject *o, void *p)
 {
@@ -300,7 +300,14 @@ void PyC_FileAndNum(const char **filename, int *lineno)
 		if (mod_name) {
 			PyObject *mod = PyDict_GetItem(PyImport_GetModuleDict(), mod_name);
 			if (mod) {
-				*filename = PyModule_GetFilename(mod);
+				PyObject *mod_file = PyModule_GetFilenameObject(mod);
+				if (mod_file) {
+					*filename = _PyUnicode_AsString(mod_name);
+					Py_DECREF(mod_file);
+				}
+				else {
+					PyErr_Clear();
+				}
 			}
 
 			/* unlikely, fallback */
@@ -918,11 +925,11 @@ char *PyC_FlagSet_AsString(PyC_FlagSet *item)
 	return cstring;
 }
 
-int PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *value)
+int PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *r_value)
 {
 	for ( ; item->identifier; item++) {
 		if (STREQ(item->identifier, identifier)) {
-			*value = item->value;
+			*r_value = item->value;
 			return 1;
 		}
 	}
@@ -930,9 +937,9 @@ int PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *
 	return 0;
 }
 
-int PyC_FlagSet_ValueFromID(PyC_FlagSet *item, const char *identifier, int *value, const char *error_prefix)
+int PyC_FlagSet_ValueFromID(PyC_FlagSet *item, const char *identifier, int *r_value, const char *error_prefix)
 {
-	if (PyC_FlagSet_ValueFromID_int(item, identifier, value) == 0) {
+	if (PyC_FlagSet_ValueFromID_int(item, identifier, r_value) == 0) {
 		const char *enum_str = PyC_FlagSet_AsString(item);
 		PyErr_Format(PyExc_ValueError,
 		             "%s: '%.200s' not found in (%s)",
@@ -1006,7 +1013,7 @@ PyObject *PyC_FlagSet_FromBitfield(PyC_FlagSet *items, int flag)
  *
  * \note it is caller's responsibility to acquire & release GIL!
  */
-bool PyC_RunString_AsNumber(const char *expr, double *value, const char *filename)
+bool PyC_RunString_AsNumber(const char *expr, const char *filename, double *r_value)
 {
 	PyObject *py_dict, *mod, *retval;
 	bool ok = true;
@@ -1058,11 +1065,48 @@ bool PyC_RunString_AsNumber(const char *expr, double *value, const char *filenam
 			ok = false;
 		}
 		else if (!isfinite(val)) {
-			*value = 0.0;
+			*r_value = 0.0;
+		}
+		else {
+			*r_value = val;
+		}
+	}
+
+	PyC_MainModule_Restore(main_mod);
+
+	return ok;
+}
+
+bool PyC_RunString_AsString(const char *expr, const char *filename, char **r_value)
+{
+	PyObject *py_dict, *retval;
+	bool ok = true;
+	PyObject *main_mod = NULL;
+
+	PyC_MainModule_Backup(&main_mod);
+
+	py_dict = PyC_DefaultNameSpace(filename);
+
+	retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
+
+	if (retval == NULL) {
+		ok = false;
+	}
+	else {
+		const char *val;
+		Py_ssize_t val_len;
+
+		val = _PyUnicode_AsStringAndSize(retval, &val_len);
+		if (val == NULL && PyErr_Occurred()) {
+			ok = false;
 		}
 		else {
-			*value = val;
+			char *val_alloc = MEM_mallocN(val_len + 1, __func__);
+			memcpy(val_alloc, val, val_len + 1);
+			*r_value = val_alloc;
 		}
+
+		Py_DECREF(retval);
 	}
 
 	PyC_MainModule_Restore(main_mod);
@@ -1071,3 +1115,101 @@ bool PyC_RunString_AsNumber(const char *expr, double *value, const char *filenam
 }
 
 #endif  /* #ifndef MATH_STANDALONE */
+
+/* -------------------------------------------------------------------- */
+
+/** \name Int Conversion
+ *
+ * \note Python doesn't provide overflow checks for specific bit-widths.
+ *
+ * \{ */
+
+/* Compiler optimizes out redundant checks. */
+#ifdef __GNUC__
+#  pragma warning(push)
+#  pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+/**
+ * Don't use `bool` return type, so -1 can be used as an error value.
+ */
+int PyC_Long_AsBool(PyObject *value)
+{
+	int test = _PyLong_AsInt(value);
+	if (UNLIKELY((uint)test > 1)) {
+		PyErr_SetString(PyExc_TypeError,
+		                "Python number not a bool (0/1)");
+		return -1;
+	}
+	return test;
+}
+
+int8_t PyC_Long_AsI8(PyObject *value)
+{
+	int test = _PyLong_AsInt(value);
+	if (UNLIKELY(test < INT8_MIN || test > INT8_MAX)) {
+		PyErr_SetString(PyExc_OverflowError,
+		                "Python int too large to convert to C int8");
+		return -1;
+	}
+	return (int8_t)test;
+}
+
+int16_t PyC_Long_AsI16(PyObject *value)
+{
+	int test = _PyLong_AsInt(value);
+	if (UNLIKELY(test < INT16_MIN || test > INT16_MAX)) {
+		PyErr_SetString(PyExc_OverflowError,
+		                "Python int too large to convert to C int16");
+		return -1;
+	}
+	return (int16_t)test;
+}
+
+/* Inlined in header:
+ * PyC_Long_AsI32
+ * PyC_Long_AsI64
+ */
+
+uint8_t PyC_Long_AsU8(PyObject *value)
+{
+	ulong test = PyLong_AsUnsignedLong(value);
+	if (UNLIKELY(test > UINT8_MAX)) {
+		PyErr_SetString(PyExc_OverflowError,
+		                "Python int too large to convert to C uint8");
+		return (uint8_t)-1;
+	}
+	return (uint8_t)test;
+}
+
+uint16_t PyC_Long_AsU16(PyObject *value)
+{
+	ulong test = PyLong_AsUnsignedLong(value);
+	if (UNLIKELY(test > UINT16_MAX)) {
+		PyErr_SetString(PyExc_OverflowError,
+		                "Python int too large to convert to C uint16");
+		return (uint16_t)-1;
+	}
+	return (uint16_t)test;
+}
+
+uint32_t PyC_Long_AsU32(PyObject *value)
+{
+	ulong test = PyLong_AsUnsignedLong(value);
+	if (UNLIKELY(test > UINT32_MAX)) {
+		PyErr_SetString(PyExc_OverflowError,
+		                "Python int too large to convert to C uint32");
+		return (uint32_t)-1;
+	}
+	return (uint32_t)test;
+}
+
+/* Inlined in header:
+ * PyC_Long_AsU64
+ */
+
+#ifdef __GNUC__
+#  pragma warning(pop)
+#endif
+
+/** \} */
diff --git a/source/blender/python/generic/py_capi_utils.h b/source/blender/python/generic/py_capi_utils.h
index 04cfc8801eb..327d4e60954 100644
--- a/source/blender/python/generic/py_capi_utils.h
+++ b/source/blender/python/generic/py_capi_utils.h
@@ -24,10 +24,12 @@
  *  \ingroup pygen
  */
 
-
 #ifndef __PY_CAPI_UTILS_H__
 #define __PY_CAPI_UTILS_H__
 
+#include "BLI_sys_types.h"
+#include "BLI_utildefines_variadic.h"
+
 void			PyC_ObSpit(const char *name, PyObject *var);
 void			PyC_LineSpit(void);
 void			PyC_StackSpit(void);
@@ -44,8 +46,21 @@ int             PyC_AsArray_FAST(
 int             PyC_AsArray(
         void *array, PyObject *value, const Py_ssize_t length,
         const PyTypeObject *type, const bool is_double, const char *error_prefix);
-PyObject *      PyC_FromArray(const void *array, int length, const PyTypeObject *type,
-                              const bool is_double, const char *error_prefix);
+
+PyObject       *PyC_Tuple_PackArray_F32(const float *array, uint len);
+PyObject       *PyC_Tuple_PackArray_I32(const int *array, uint len);
+PyObject       *PyC_Tuple_PackArray_I32FromBool(const int *array, uint len);
+PyObject       *PyC_Tuple_PackArray_Bool(const bool *array, uint len);
+
+#define PyC_Tuple_Pack_F32(...) \
+	PyC_Tuple_PackArray_F32(((const float []){__VA_ARGS__}), VA_NARGS_COUNT(__VA_ARGS__))
+#define PyC_Tuple_Pack_I32(...) \
+	PyC_Tuple_PackArray_I32(((const int []){__VA_ARGS__}), VA_NARGS_COUNT(__VA_ARGS__))
+#define PyC_Tuple_Pack_I32FromBool(...) \
+	PyC_Tuple_PackArray_I32FromBool(((const int []){__VA_ARGS__}), VA_NARGS_COUNT(__VA_ARGS__))
+#define PyC_Tuple_Pack_Bool(...) \
+	PyC_Tuple_PackArray_Bool(((const bool []){__VA_ARGS__}), VA_NARGS_COUNT(__VA_ARGS__))
+
 void            PyC_Tuple_Fill(PyObject *tuple, PyObject *value);
 void            PyC_List_Fill(PyObject *list, PyObject *value);
 
@@ -75,13 +90,36 @@ typedef struct PyC_FlagSet {
 } PyC_FlagSet;
 
 char     *PyC_FlagSet_AsString(PyC_FlagSet *item);
-int       PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *value);
-int       PyC_FlagSet_ValueFromID(PyC_FlagSet *item, const char *identifier, int *value, const char *error_prefix);
+int       PyC_FlagSet_ValueFromID_int(PyC_FlagSet *item, const char *identifier, int *r_value);
+int       PyC_FlagSet_ValueFromID(PyC_FlagSet *item, const char *identifier, int *r_value, const char *error_prefix);
 int       PyC_FlagSet_ToBitfield(PyC_FlagSet *items, PyObject *value, int *r_value, const char *error_prefix);
 PyObject *PyC_FlagSet_FromBitfield(PyC_FlagSet *items, int flag);
 
-bool PyC_RunString_AsNumber(const char *expr, double *value, const char *filename);
+bool PyC_RunString_AsNumber(const char *expr, const char *filename, double *r_value);
+bool PyC_RunString_AsString(const char *expr, const char *filename, char **r_value);
 
 int PyC_ParseBool(PyObject *o, void *p);
 
+
+/* Integer parsing (with overflow checks), -1 on error. */
+int     PyC_Long_AsBool(PyObject *value);
+int8_t  PyC_Long_AsI8(PyObject *value);
+int16_t PyC_Long_AsI16(PyObject *value);
+#if 0 /* inline */
+int32_t PyC_Long_AsI32(PyObject *value);
+int64_t PyC_Long_AsI64(PyObject *value);
+#endif
+
+uint8_t  PyC_Long_AsU8(PyObject *value);
+uint16_t PyC_Long_AsU16(PyObject *value);
+uint32_t PyC_Long_AsU32(PyObject *value);
+#if 0 /* inline */
+uint64_t PyC_Long_AsU64(PyObject *value);
+#endif
+
+/* inline so type signatures match as expected */
+Py_LOCAL_INLINE(int32_t)  PyC_Long_AsI32(PyObject *value) { return (int32_t)_PyLong_AsInt(value); }
+Py_LOCAL_INLINE(int64_t)  PyC_Long_AsI64(PyObject *value) { return (int64_t)PyLong_AsLongLong(value); }
+Py_LOCAL_INLINE(uint64_t) PyC_Long_AsU64(PyObject *value) { return (uint64_t)PyLong_AsUnsignedLongLong(value); }
+
 #endif  /* __PY_CAPI_UTILS_H__ */
diff --git a/source/blender/python/generic/python_utildefines.h b/source/blender/python/generic/python_utildefines.h
index f7d3e7a8b4a..2d2d19c05f5 100644
--- a/source/blender/python/generic/python_utildefines.h
+++ b/source/blender/python/generic/python_utildefines.h
@@ -36,16 +36,16 @@ extern "C" {
 	PyTupleObject *op = (PyTupleObject *)op_arg; \
 	PyObject **ob_items = op->ob_item; \
 	CHECK_TYPE_ANY(op_arg, PyObject *, PyTupleObject *); \
-	BLI_assert(_VA_NARGS_COUNT(__VA_ARGS__) == PyTuple_GET_SIZE(op)); \
+	BLI_assert(VA_NARGS_COUNT(__VA_ARGS__) == PyTuple_GET_SIZE(op)); \
 	ARRAY_SET_ITEMS(ob_items, __VA_ARGS__); \
 } (void)0
 
 /* wrap Py_INCREF & return the result,
  * use sparingly to avoid comma operator or temp var assignment */
-BLI_INLINE PyObject *Py_INCREF_RET(PyObject *op) { Py_INCREF(op); return op; }
+Py_LOCAL_INLINE(PyObject *)Py_INCREF_RET(PyObject *op) { Py_INCREF(op); return op; }
 
 /* append & transfer ownership to the list, avoids inline Py_DECREF all over (which is quite a large macro) */
-BLI_INLINE int PyList_APPEND(PyObject *op, PyObject *v)
+Py_LOCAL_INLINE(int) PyList_APPEND(PyObject *op, PyObject *v)
 {
 	int ret = PyList_Append(op, v);
 	Py_DecRef(v);