Custom Menus : merge master

47 files changed, 724 insertions, 549 deletions

diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h
index 7bcf96116b9..e1e0d01055a 100644
--- a/source/blender/python/BPY_extern.h
+++ b/source/blender/python/BPY_extern.h
@@ -50,12 +50,6 @@ void BPY_pyconstraint_update(struct Object *owner, struct bConstraint *con);
 int BPY_is_pyconstraint(struct Text *text);
 //  void BPY_free_pyconstraint_links(struct Text *text);
 
-void BPY_python_start(int argc, const char **argv);
-void BPY_python_end(void);
-void BPY_python_reset(struct bContext *C);
-void BPY_python_use_system_env(void);
-void BPY_python_backtrace(/* FILE */ void *file);
-
 /* global interpreter lock */
 
 typedef void *BPy_ThreadStatePtr;
@@ -73,40 +67,6 @@ void BPY_thread_restore(BPy_ThreadStatePtr tstate);
   } \
   (void)0
 
-bool BPY_execute_filepath(struct bContext *C, const char *filepath, struct ReportList *reports);
-bool BPY_execute_text(struct bContext *C,
-                      struct Text *text,
-                      struct ReportList *reports,
-                      const bool do_jump);
-
-bool BPY_execute_string_as_number(struct bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  double *r_value);
-bool BPY_execute_string_as_intptr(struct bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  intptr_t *r_value);
-bool BPY_execute_string_as_string_and_size(struct bContext *C,
-                                           const char *imports[],
-                                           const char *expr,
-                                           const char *report_prefix,
-                                           char **r_value,
-                                           size_t *r_value_size);
-bool BPY_execute_string_as_string(struct bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  char **r_value);
-
-bool BPY_execute_string_ex(struct bContext *C,
-                           const char *imports[],
-                           const char *expr,
-                           bool use_eval);
-bool BPY_execute_string(struct bContext *C, const char *imports[], const char *expr);
-
 void BPY_text_free_code(struct Text *text);
 void BPY_modules_update(
     struct bContext *C);  // XXX - annoying, need this for pointers that get out of date
diff --git a/source/blender/python/BPY_extern_python.h b/source/blender/python/BPY_extern_python.h
new file mode 100644
index 00000000000..348f6986863
--- /dev/null
+++ b/source/blender/python/BPY_extern_python.h
@@ -0,0 +1,43 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup python
+ *
+ * Functionality relating to Python setup & tear down.
+ */
+
+#pragma once
+
+struct bContext;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* For 'FILE'. */
+#include <stdio.h>
+
+/* bpy_interface.c */
+void BPY_python_start(int argc, const char **argv);
+void BPY_python_end(void);
+void BPY_python_reset(struct bContext *C);
+void BPY_python_use_system_env(void);
+void BPY_python_backtrace(FILE *file);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
diff --git a/source/blender/python/BPY_extern_run.h b/source/blender/python/BPY_extern_run.h
new file mode 100644
index 00000000000..5f12ada4ff2
--- /dev/null
+++ b/source/blender/python/BPY_extern_run.h
@@ -0,0 +1,70 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup python
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "BLI_sys_types.h"
+
+struct ReportList;
+struct Text;
+struct bContext;
+
+/* bpy_interface_run.c */
+bool BPY_run_filepath(struct bContext *C, const char *filepath, struct ReportList *reports);
+bool BPY_run_text(struct bContext *C,
+                  struct Text *text,
+                  struct ReportList *reports,
+                  const bool do_jump);
+
+/* Use the 'eval' for simple single-line expressions,
+ * otherwise 'exec' for full multi-line scripts. */
+bool BPY_run_string_exec(struct bContext *C, const char *imports[], const char *expr);
+bool BPY_run_string_eval(struct bContext *C, const char *imports[], const char *expr);
+
+/* Run, evaluating to fixed type result. */
+bool BPY_run_string_as_number(struct bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              double *r_value);
+bool BPY_run_string_as_intptr(struct bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              intptr_t *r_value);
+bool BPY_run_string_as_string_and_size(struct bContext *C,
+                                       const char *imports[],
+                                       const char *expr,
+                                       const char *report_prefix,
+                                       char **r_value,
+                                       size_t *r_value_size);
+bool BPY_run_string_as_string(struct bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              char **r_value);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
diff --git a/source/blender/python/bmesh/CMakeLists.txt b/source/blender/python/bmesh/CMakeLists.txt
index 818498fe7db..89df127075d 100644
--- a/source/blender/python/bmesh/CMakeLists.txt
+++ b/source/blender/python/bmesh/CMakeLists.txt
@@ -64,4 +64,8 @@ if(WITH_FREESTYLE)
   add_definitions(-DWITH_FREESTYLE)
 endif()
 
+if(WITH_GMP)
+  add_definitions(-DWITH_GMP)
+endif()
+
 blender_add_lib(bf_python_bmesh "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
diff --git a/source/blender/python/bmesh/bmesh_py_ops_call.c b/source/blender/python/bmesh/bmesh_py_ops_call.c
index a387ba31c84..d0676ec1947 100644
--- a/source/blender/python/bmesh/bmesh_py_ops_call.c
+++ b/source/blender/python/bmesh/bmesh_py_ops_call.c
@@ -228,7 +228,7 @@ static int bpy_slot_from_py(BMesh *bm,
       break;
     }
     case BMO_OP_SLOT_FLT: {
-      float param = PyFloat_AsDouble(value);
+      const float param = PyFloat_AsDouble(value);
       if (param == -1 && PyErr_Occurred()) {
         PyErr_Format(PyExc_TypeError,
                      "%.200s: keyword \"%.200s\" expected a float, not %.200s",
@@ -840,7 +840,7 @@ PyObject *BPy_BMO_call(BPy_BMeshOpFunc *self, PyObject *args, PyObject *kw)
       {
         char slot_name_strip[MAX_SLOTNAME];
         const char *ch = strchr(slot->slot_name, '.'); /* can't fail! */
-        int tot = ch - slot->slot_name;
+        const int tot = ch - slot->slot_name;
         BLI_assert(ch != NULL);
         memcpy(slot_name_strip, slot->slot_name, tot);
         slot_name_strip[tot] = '\0';
diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c
index e39b5faf3c4..2b174de7136 100644
--- a/source/blender/python/bmesh/bmesh_py_types.c
+++ b/source/blender/python/bmesh/bmesh_py_types.c
@@ -1093,7 +1093,7 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
   bool use_deform = true;
   bool use_cage = false;
   bool use_fnorm = true;
-  CustomData_MeshMasks data_masks = CD_MASK_BMESH;
+  const CustomData_MeshMasks data_masks = CD_MASK_BMESH;
 
   BPY_BM_CHECK_OBJ(self);
 
@@ -1134,7 +1134,7 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
         return NULL;
       }
 
-      me_eval = mesh_create_eval_final_render(depsgraph, scene_eval, ob_eval, &data_masks);
+      me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &data_masks);
     }
     else {
       if (use_cage) {
@@ -1346,7 +1346,7 @@ static PyObject *bpy_bmesh_transform(BPy_BMElem *self, PyObject *args, PyObject
     }
   }
   else {
-    char filter_flags_ch = (char)filter_flags;
+    const char filter_flags_ch = (char)filter_flags;
     BM_ITER_MESH (eve, &iter, self->bm, BM_VERTS_OF_MESH) {
       if (BM_elem_flag_test(eve, filter_flags_ch)) {
         mul_m4_v3((float(*)[4])mat_ptr, eve->co);
@@ -3222,7 +3222,7 @@ static PyObject *bpy_bmelemseq_subscript(BPy_BMElemSeq *self, PyObject *key)
 {
   /* don't need error check here */
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return NULL;
     }
@@ -3255,7 +3255,7 @@ static PyObject *bpy_bmelemseq_subscript(BPy_BMElemSeq *self, PyObject *key)
 
     if (start < 0 || stop < 0) {
       /* only get the length for negative values */
-      Py_ssize_t len = bpy_bmelemseq_length(self);
+      const Py_ssize_t len = bpy_bmelemseq_length(self);
       if (start < 0) {
         start += len;
       }
diff --git a/source/blender/python/bmesh/bmesh_py_types_customdata.c b/source/blender/python/bmesh/bmesh_py_types_customdata.c
index 51616030d30..a9a9a3ad5d9 100644
--- a/source/blender/python/bmesh/bmesh_py_types_customdata.c
+++ b/source/blender/python/bmesh/bmesh_py_types_customdata.c
@@ -714,7 +714,7 @@ static PyObject *bpy_bmlayercollection_subscript_slice(BPy_BMLayerCollection *se
                                                        Py_ssize_t start,
                                                        Py_ssize_t stop)
 {
-  Py_ssize_t len = bpy_bmlayercollection_length(self);
+  const Py_ssize_t len = bpy_bmlayercollection_length(self);
   int count = 0;
 
   PyObject *tuple;
@@ -746,7 +746,7 @@ static PyObject *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, Py
     return bpy_bmlayercollection_subscript_str(self, _PyUnicode_AsString(key));
   }
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return NULL;
     }
@@ -779,7 +779,7 @@ static PyObject *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, Py
 
     if (start < 0 || stop < 0) {
       /* only get the length for negative values */
-      Py_ssize_t len = bpy_bmlayercollection_length(self);
+      const Py_ssize_t len = bpy_bmlayercollection_length(self);
       if (start < 0) {
         start += len;
       }
@@ -1127,7 +1127,7 @@ int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObj
     }
     case CD_PROP_FLOAT:
     case CD_PAINT_MASK: {
-      float tmp_val = PyFloat_AsDouble(py_value);
+      const float tmp_val = PyFloat_AsDouble(py_value);
       if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) {
         PyErr_Format(
             PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name);
@@ -1140,7 +1140,7 @@ int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObj
     }
     case CD_PROP_INT32:
     case CD_FACEMAP: {
-      int tmp_val = PyC_Long_AsI32(py_value);
+      const int tmp_val = PyC_Long_AsI32(py_value);
       if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) {
         /* error is set */
         ret = -1;
@@ -1187,7 +1187,7 @@ int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObj
       break;
     }
     case CD_BWEIGHT: {
-      float tmp_val = PyFloat_AsDouble(py_value);
+      const float tmp_val = PyFloat_AsDouble(py_value);
       if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) {
         PyErr_Format(
             PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name);
@@ -1199,7 +1199,7 @@ int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObj
       break;
     }
     case CD_CREASE: {
-      float tmp_val = PyFloat_AsDouble(py_value);
+      const float tmp_val = PyFloat_AsDouble(py_value);
       if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) {
         PyErr_Format(
             PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name);
diff --git a/source/blender/python/bmesh/bmesh_py_types_select.c b/source/blender/python/bmesh/bmesh_py_types_select.c
index d69668341ff..9bb9815f731 100644
--- a/source/blender/python/bmesh/bmesh_py_types_select.c
+++ b/source/blender/python/bmesh/bmesh_py_types_select.c
@@ -246,7 +246,7 @@ static PyObject *bpy_bmeditselseq_subscript(BPy_BMEditSelSeq *self, PyObject *ke
 {
   /* don't need error check here */
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return NULL;
     }
@@ -279,7 +279,7 @@ static PyObject *bpy_bmeditselseq_subscript(BPy_BMEditSelSeq *self, PyObject *ke
 
     if (start < 0 || stop < 0) {
       /* only get the length for negative values */
-      Py_ssize_t len = bpy_bmeditselseq_length(self);
+      const Py_ssize_t len = bpy_bmeditselseq_length(self);
       if (start < 0) {
         start += len;
       }
diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt
index 785c1d66407..dce6a7e1c91 100644
--- a/source/blender/python/generic/CMakeLists.txt
+++ b/source/blender/python/generic/CMakeLists.txt
@@ -32,18 +32,18 @@ set(INC_SYS
 
 set(SRC
   bgl.c
+  bl_math_py_api.c
   blf_py_api.c
   bpy_threads.c
   idprop_py_api.c
   imbuf_py_api.c
-  bl_math_py_api.c
   py_capi_utils.c
 
   bgl.h
+  bl_math_py_api.h
   blf_py_api.h
   idprop_py_api.h
   imbuf_py_api.h
-  bl_math_py_api.h
   py_capi_utils.h
 
   # header-only
diff --git a/source/blender/python/generic/bgl.c b/source/blender/python/generic/bgl.c
index 405541554c9..89fe9f8c6aa 100644
--- a/source/blender/python/generic/bgl.c
+++ b/source/blender/python/generic/bgl.c
@@ -461,7 +461,7 @@ int BGL_typeSize(int type)
 static int gl_buffer_type_from_py_buffer(Py_buffer *pybuffer)
 {
   const char format = PyC_StructFmt_type_from_str(pybuffer->format);
-  Py_ssize_t itemsize = pybuffer->itemsize;
+  const Py_ssize_t itemsize = pybuffer->itemsize;
 
   if (PyC_StructFmt_type_is_float_any(format)) {
     if (itemsize == 4) {
@@ -705,7 +705,7 @@ static int BGL_BufferOrOffsetConverter(PyObject *object, BufferOrOffset *buffer)
     return 1;
   }
   if (PyNumber_Check(object)) {
-    Py_ssize_t offset = PyNumber_AsSsize_t(object, PyExc_IndexError);
+    const Py_ssize_t offset = PyNumber_AsSsize_t(object, PyExc_IndexError);
     if (offset == -1 && PyErr_Occurred()) {
       return 0;
     }
@@ -907,7 +907,7 @@ static int Buffer_ass_item(Buffer *self, int i, PyObject *v)
     Buffer *row = (Buffer *)Buffer_item(self, i);
 
     if (row) {
-      int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v);
+      const int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v);
       Py_DECREF(row);
       return ret;
     }
diff --git a/source/blender/python/generic/idprop_py_api.c b/source/blender/python/generic/idprop_py_api.c
index 615ce514a3e..314a34e3dec 100644
--- a/source/blender/python/generic/idprop_py_api.c
+++ b/source/blender/python/generic/idprop_py_api.c
@@ -435,7 +435,7 @@ static IDProperty *idp_from_PyBytes(const char *name, PyObject *ob)
 
 static int idp_array_type_from_formatstr_and_size(const char *typestr, Py_ssize_t itemsize)
 {
-  char format = PyC_StructFmt_type_from_str(typestr);
+  const char format = PyC_StructFmt_type_from_str(typestr);
 
   if (PyC_StructFmt_type_is_float_any(format)) {
     if (itemsize == 4) {
@@ -473,7 +473,7 @@ static IDProperty *idp_from_PySequence_Buffer(const char *name, Py_buffer *buffe
   IDProperty *prop;
   IDPropertyTemplate val = {0};
 
-  int id_type = idp_array_type_from_formatstr_and_size(buffer->format, buffer->itemsize);
+  const int id_type = idp_array_type_from_formatstr_and_size(buffer->format, buffer->itemsize);
   if (id_type == -1) {
     /* should never happen as the type has been checked before */
     return NULL;
@@ -560,7 +560,7 @@ static IDProperty *idp_from_PySequence(const char *name, PyObject *ob)
 
   if (PyObject_CheckBuffer(ob)) {
     PyObject_GetBuffer(ob, &buffer, PyBUF_SIMPLE | PyBUF_FORMAT);
-    char format = PyC_StructFmt_type_from_str(buffer.format);
+    const char format = PyC_StructFmt_type_from_str(buffer.format);
     if (PyC_StructFmt_type_is_float_any(format) ||
         (PyC_StructFmt_type_is_int_any(format) && buffer.itemsize == 4)) {
       use_buffer = true;
@@ -589,7 +589,7 @@ static IDProperty *idp_from_PySequence(const char *name, PyObject *ob)
 static IDProperty *idp_from_PyMapping(const char *name, PyObject *ob)
 {
   IDProperty *prop;
-  IDPropertyTemplate val = {0};
+  const IDPropertyTemplate val = {0};
 
   PyObject *keys, *vals, *key, *pval;
   int i, len;
@@ -1559,8 +1559,8 @@ static int itemsize_by_idarray_type(int array_type)
 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;
+  const int itemsize = itemsize_by_idarray_type(prop->subtype);
+  const int length = itemsize * prop->len;
 
   if (PyBuffer_FillInfo(view, (PyObject *)self, IDP_Array(prop), length, false, flags) == -1) {
     return -1;
diff --git a/source/blender/python/generic/imbuf_py_api.c b/source/blender/python/generic/imbuf_py_api.c
index 3536236754e..5dc4aa6ce7c 100644
--- a/source/blender/python/generic/imbuf_py_api.c
+++ b/source/blender/python/generic/imbuf_py_api.c
@@ -260,7 +260,7 @@ static int py_imbuf_filepath_set(Py_ImBuf *self, PyObject *value, void *UNUSED(c
   }
 
   ImBuf *ibuf = self->ibuf;
-  Py_ssize_t value_str_len_max = sizeof(ibuf->name);
+  const Py_ssize_t value_str_len_max = sizeof(ibuf->name);
   Py_ssize_t value_str_len;
   const char *value_str = _PyUnicode_AsStringAndSize(value, &value_str_len);
   if (value_str_len >= value_str_len_max) {
@@ -425,8 +425,8 @@ static PyObject *M_imbuf_new(PyObject *UNUSED(self), PyObject *args, PyObject *k
   }
 
   /* TODO, make options */
-  uchar planes = 4;
-  uint flags = IB_rect;
+  const uchar planes = 4;
+  const uint flags = IB_rect;
 
   ImBuf *ibuf = IMB_allocImBuf(UNPACK2(size), planes, flags);
   if (ibuf == NULL) {
@@ -500,7 +500,7 @@ static PyObject *M_imbuf_write(PyObject *UNUSED(self), PyObject *args, PyObject
     filepath = py_imb->ibuf->name;
   }
 
-  bool ok = IMB_saveiff(py_imb->ibuf, filepath, IB_rect);
+  const bool ok = IMB_saveiff(py_imb->ibuf, filepath, IB_rect);
   if (ok == false) {
     PyErr_Format(
         PyExc_IOError, "write: Unable to write image file (%s) '%s'", strerror(errno), filepath);
diff --git a/source/blender/python/generic/py_capi_utils.c b/source/blender/python/generic/py_capi_utils.c
index caae5c4e122..195442d34f6 100644
--- a/source/blender/python/generic/py_capi_utils.c
+++ b/source/blender/python/generic/py_capi_utils.c
@@ -207,7 +207,7 @@ PyObject *PyC_Tuple_PackArray_Bool(const bool *array, uint len)
  */
 void PyC_Tuple_Fill(PyObject *tuple, PyObject *value)
 {
-  uint tot = PyTuple_GET_SIZE(tuple);
+  const uint tot = PyTuple_GET_SIZE(tuple);
   uint i;
 
   for (i = 0; i < tot; i++) {
@@ -218,7 +218,7 @@ void PyC_Tuple_Fill(PyObject *tuple, PyObject *value)
 
 void PyC_List_Fill(PyObject *list, PyObject *value)
 {
-  uint tot = PyList_GET_SIZE(list);
+  const uint tot = PyList_GET_SIZE(list);
   uint i;
 
   for (i = 0; i < tot; i++) {
@@ -377,25 +377,11 @@ void PyC_StackSpit(void)
   }
 
   /* lame but handy */
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
   PyRun_SimpleString("__import__('traceback').print_stack()");
   PyGILState_Release(gilstate);
 }
 
-void PyC_StackPrint(/* FILE */ void *fp)
-{
-  PyThreadState *tstate = PyGILState_GetThisThreadState();
-  if (tstate != NULL && tstate->frame != NULL) {
-    PyFrameObject *frame = tstate->frame;
-    do {
-      const int line = PyCode_Addr2Line(frame->f_code, frame->f_lasti);
-      const char *filename = _PyUnicode_AsString(frame->f_code->co_filename);
-      const char *funcname = _PyUnicode_AsString(frame->f_code->co_name);
-      fprintf(fp, "  File \"%s\", line %d in %s\n", filename, line, funcname);
-    } while ((frame = frame->f_back));
-  }
-}
-
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -962,7 +948,7 @@ void PyC_RunQuicky(const char *filepath, int n, ...)
   FILE *fp = fopen(filepath, "r");
 
   if (fp) {
-    PyGILState_STATE gilstate = PyGILState_Ensure();
+    const PyGILState_STATE gilstate = PyGILState_Ensure();
 
     va_list vargs;
 
@@ -1437,7 +1423,7 @@ bool PyC_RunString_AsString(const char *imports[],
  */
 int PyC_Long_AsBool(PyObject *value)
 {
-  int test = _PyLong_AsInt(value);
+  const int test = _PyLong_AsInt(value);
   if (UNLIKELY((uint)test > 1)) {
     PyErr_SetString(PyExc_TypeError, "Python number not a bool (0/1)");
     return -1;
@@ -1447,7 +1433,7 @@ int PyC_Long_AsBool(PyObject *value)
 
 int8_t PyC_Long_AsI8(PyObject *value)
 {
-  int test = _PyLong_AsInt(value);
+  const 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;
@@ -1457,7 +1443,7 @@ int8_t PyC_Long_AsI8(PyObject *value)
 
 int16_t PyC_Long_AsI16(PyObject *value)
 {
-  int test = _PyLong_AsInt(value);
+  const 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;
@@ -1472,7 +1458,7 @@ int16_t PyC_Long_AsI16(PyObject *value)
 
 uint8_t PyC_Long_AsU8(PyObject *value)
 {
-  ulong test = PyLong_AsUnsignedLong(value);
+  const 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;
@@ -1482,7 +1468,7 @@ uint8_t PyC_Long_AsU8(PyObject *value)
 
 uint16_t PyC_Long_AsU16(PyObject *value)
 {
-  ulong test = PyLong_AsUnsignedLong(value);
+  const 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;
@@ -1492,7 +1478,7 @@ uint16_t PyC_Long_AsU16(PyObject *value)
 
 uint32_t PyC_Long_AsU32(PyObject *value)
 {
-  ulong test = PyLong_AsUnsignedLong(value);
+  const 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;
diff --git a/source/blender/python/generic/py_capi_utils.h b/source/blender/python/generic/py_capi_utils.h
index dde450012d0..e8b2e8ff502 100644
--- a/source/blender/python/generic/py_capi_utils.h
+++ b/source/blender/python/generic/py_capi_utils.h
@@ -28,7 +28,6 @@ void PyC_ObSpit(const char *name, PyObject *var);
 void PyC_ObSpitStr(char *result, size_t result_len, PyObject *var);
 void PyC_LineSpit(void);
 void PyC_StackSpit(void);
-void PyC_StackPrint(/* FILE */ void *fp);
 PyObject *PyC_ExceptionBuffer(void);
 PyObject *PyC_ExceptionBuffer_Simple(void);
 PyObject *PyC_Object_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...);
diff --git a/source/blender/python/gpu/gpu_py_batch.c b/source/blender/python/gpu/gpu_py_batch.c
index 01bccc57c7a..bb7028c11ab 100644
--- a/source/blender/python/gpu/gpu_py_batch.c
+++ b/source/blender/python/gpu/gpu_py_batch.c
@@ -50,7 +50,7 @@
 
 static bool bpygpu_batch_is_program_or_error(BPyGPUBatch *self)
 {
-  if (!glIsProgram(self->batch->program)) {
+  if (!self->batch->shader) {
     PyErr_SetString(PyExc_RuntimeError, "batch does not have any program assigned to it");
     return false;
   }
@@ -227,7 +227,7 @@ static PyObject *bpygpu_Batch_draw(BPyGPUBatch *self, PyObject *args)
       return NULL;
     }
   }
-  else if (self->batch->program != GPU_shader_get_program(py_program->shader)) {
+  else if (self->batch->shader != py_program->shader) {
     GPU_batch_set_shader(self->batch, py_program->shader);
   }
 
@@ -240,7 +240,7 @@ static PyObject *bpygpu_Batch_program_use_begin(BPyGPUBatch *self)
   if (!bpygpu_batch_is_program_or_error(self)) {
     return NULL;
   }
-  GPU_batch_program_use_begin(self->batch);
+  GPU_shader_bind(self->batch->shader);
   Py_RETURN_NONE;
 }
 
@@ -249,7 +249,7 @@ static PyObject *bpygpu_Batch_program_use_end(BPyGPUBatch *self)
   if (!bpygpu_batch_is_program_or_error(self)) {
     return NULL;
   }
-  GPU_batch_program_use_end(self->batch);
+  GPU_shader_unbind();
   Py_RETURN_NONE;
 }
 
diff --git a/source/blender/python/gpu/gpu_py_offscreen.c b/source/blender/python/gpu/gpu_py_offscreen.c
index e56f87e6221..15c39de990b 100644
--- a/source/blender/python/gpu/gpu_py_offscreen.c
+++ b/source/blender/python/gpu/gpu_py_offscreen.c
@@ -246,7 +246,7 @@ static PyObject *bpygpu_offscreen_draw_view3d(BPyGPUOffScreen *self,
 
   BLI_assert(BKE_id_is_in_global_main(&scene->id));
 
-  depsgraph = BKE_scene_get_depsgraph(G_MAIN, scene, view_layer, true);
+  depsgraph = BKE_scene_ensure_depsgraph(G_MAIN, scene, view_layer);
 
   rv3d_mats = ED_view3d_mats_rv3d_backup(region->regiondata);
 
diff --git a/source/blender/python/gpu/gpu_py_shader.c b/source/blender/python/gpu/gpu_py_shader.c
index 165286c3661..f9ff0558570 100644
--- a/source/blender/python/gpu/gpu_py_shader.c
+++ b/source/blender/python/gpu/gpu_py_shader.c
@@ -78,7 +78,7 @@ static int bpygpu_uniform_location_get(GPUShader *shader,
                                        const char *name,
                                        const char *error_prefix)
 {
-  int uniform = GPU_shader_get_uniform(shader, name);
+  const int uniform = GPU_shader_get_uniform(shader, name);
 
   if (uniform == -1) {
     PyErr_Format(PyExc_ValueError, "%s: uniform %.32s not found", error_prefix, name);
@@ -158,7 +158,7 @@ static PyObject *bpygpu_shader_uniform_from_name(BPyGPUShader *self, PyObject *a
     return NULL;
   }
 
-  int uniform = bpygpu_uniform_location_get(self->shader, name, "GPUShader.get_uniform");
+  const int uniform = bpygpu_uniform_location_get(self->shader, name, "GPUShader.get_uniform");
 
   if (uniform == -1) {
     return NULL;
@@ -184,7 +184,7 @@ static PyObject *bpygpu_shader_uniform_block_from_name(BPyGPUShader *self, PyObj
     return NULL;
   }
 
-  int uniform = GPU_shader_get_uniform_block(self->shader, name);
+  const int uniform = GPU_shader_get_uniform_block(self->shader, name);
 
   if (uniform == -1) {
     PyErr_Format(PyExc_ValueError, "GPUShader.get_uniform_block: uniform %.32s not found", name);
@@ -504,7 +504,7 @@ static PyObject *bpygpu_shader_attr_from_name(BPyGPUShader *self, PyObject *arg)
     return NULL;
   }
 
-  int attr = GPU_shader_get_attribute(self->shader, name);
+  const int attr = GPU_shader_get_attribute(self->shader, name);
 
   if (attr == -1) {
     PyErr_Format(PyExc_ValueError, "GPUShader.attr_from_name: attribute %.32s not found", name);
@@ -604,7 +604,8 @@ PyDoc_STRVAR(
     "   ``GPU_ATI``, ``GPU_NVIDIA`` and ``GPU_INTEL``.\n"
     "\n"
     "   The following extensions are enabled by default if supported by the GPU:\n"
-    "   ``GL_ARB_texture_gather`` and ``GL_ARB_texture_query_lod``.\n"
+    "   ``GL_ARB_texture_gather``, ``GL_ARB_texture_cube_map_array`` and "
+    "``GL_ARB_shader_draw_parameters``.\n"
     "\n"
     "   To debug shaders, use the --debug-gpu-shaders command line option"
     "   to see full GLSL shader compilation and linking errors.\n"
diff --git a/source/blender/python/gpu/gpu_py_vertex_buffer.c b/source/blender/python/gpu/gpu_py_vertex_buffer.c
index 57290fdc3c4..9372770e45e 100644
--- a/source/blender/python/gpu/gpu_py_vertex_buffer.c
+++ b/source/blender/python/gpu/gpu_py_vertex_buffer.c
@@ -134,7 +134,7 @@ static bool bpygpu_vertbuf_fill_impl(GPUVertBuf *vbo,
       return false;
     }
 
-    uint comp_len = pybuffer.ndim == 1 ? 1 : (uint)pybuffer.shape[1];
+    const uint comp_len = pybuffer.ndim == 1 ? 1 : (uint)pybuffer.shape[1];
 
     if (pybuffer.shape[0] != vbo->vertex_len) {
       PyErr_Format(
diff --git a/source/blender/python/gpu/gpu_py_vertex_format.c b/source/blender/python/gpu/gpu_py_vertex_format.c
index d8266be7e2c..1cbcaba6bfb 100644
--- a/source/blender/python/gpu/gpu_py_vertex_format.c
+++ b/source/blender/python/gpu/gpu_py_vertex_format.c
@@ -112,7 +112,7 @@ static int bpygpu_ParseVertCompType(PyObject *o, void *p)
     return 0;
   }
 
-  int comp_type = bpygpu_parse_component_type(str, length);
+  const int comp_type = bpygpu_parse_component_type(str, length);
   if (comp_type == -1) {
     PyErr_Format(PyExc_ValueError, "unknown component type: '%s", str);
     return 0;
@@ -132,7 +132,7 @@ static int bpygpu_ParseVertFetchMode(PyObject *o, void *p)
     return 0;
   }
 
-  int fetch_mode = bpygpu_parse_fetch_mode(str, length);
+  const int fetch_mode = bpygpu_parse_fetch_mode(str, length);
   if (fetch_mode == -1) {
     PyErr_Format(PyExc_ValueError, "unknown type literal: '%s'", str);
     return 0;
diff --git a/source/blender/python/intern/CMakeLists.txt b/source/blender/python/intern/CMakeLists.txt
index 769618005af..44949c478cc 100644
--- a/source/blender/python/intern/CMakeLists.txt
+++ b/source/blender/python/intern/CMakeLists.txt
@@ -62,6 +62,7 @@ set(SRC
   bpy_gizmo_wrap.c
   bpy_interface.c
   bpy_interface_atexit.c
+  bpy_interface_run.c
   bpy_intern_string.c
   bpy_library_load.c
   bpy_library_write.c
diff --git a/source/blender/python/intern/bpy_app.c b/source/blender/python/intern/bpy_app.c
index 4ee936aff91..f0de05f95b3 100644
--- a/source/blender/python/intern/bpy_app.c
+++ b/source/blender/python/intern/bpy_app.c
@@ -343,7 +343,7 @@ static PyObject *bpy_app_debug_value_get(PyObject *UNUSED(self), void *UNUSED(cl
 
 static int bpy_app_debug_value_set(PyObject *UNUSED(self), PyObject *value, void *UNUSED(closure))
 {
-  short param = PyC_Long_AsI16(value);
+  const short param = PyC_Long_AsI16(value);
 
   if (param == -1 && PyErr_Occurred()) {
     PyC_Err_SetString_Prefix(PyExc_TypeError,
diff --git a/source/blender/python/intern/bpy_app_handlers.c b/source/blender/python/intern/bpy_app_handlers.c
index cdbd3bc0b9c..a874e23ff32 100644
--- a/source/blender/python/intern/bpy_app_handlers.c
+++ b/source/blender/python/intern/bpy_app_handlers.c
@@ -318,7 +318,7 @@ void bpy_app_generic_callback(struct Main *UNUSED(main),
 {
   PyObject *cb_list = py_cb_array[POINTER_AS_INT(arg)];
   if (PyList_GET_SIZE(cb_list) > 0) {
-    PyGILState_STATE gilstate = PyGILState_Ensure();
+    const PyGILState_STATE gilstate = PyGILState_Ensure();
 
     const int num_arguments = 2;
     PyObject *args_all = PyTuple_New(num_arguments); /* save python creating each call */
diff --git a/source/blender/python/intern/bpy_app_icons.c b/source/blender/python/intern/bpy_app_icons.c
index 2e688609961..7cca3ae4700 100644
--- a/source/blender/python/intern/bpy_app_icons.c
+++ b/source/blender/python/intern/bpy_app_icons.c
@@ -71,8 +71,8 @@ static PyObject *bpy_app_icons_new_triangles(PyObject *UNUSED(self), PyObject *a
     return NULL;
   }
 
-  int coords_size = sizeof(uchar[2]) * tris_len * 3;
-  int colors_size = sizeof(uchar[4]) * tris_len * 3;
+  const int coords_size = sizeof(uchar[2]) * tris_len * 3;
+  const int colors_size = sizeof(uchar[4]) * tris_len * 3;
   uchar(*coords)[2] = MEM_mallocN(coords_size, __func__);
   uchar(*colors)[4] = MEM_mallocN(colors_size, __func__);
 
@@ -86,7 +86,7 @@ static PyObject *bpy_app_icons_new_triangles(PyObject *UNUSED(self), PyObject *a
   geom->coords = coords;
   geom->colors = colors;
   geom->icon_id = 0;
-  int icon_id = BKE_icon_geom_ensure(geom);
+  const int icon_id = BKE_icon_geom_ensure(geom);
   return PyLong_FromLong(icon_id);
 }
 
@@ -117,7 +117,7 @@ static PyObject *bpy_app_icons_new_triangles_from_file(PyObject *UNUSED(self),
     PyErr_SetString(PyExc_ValueError, "Unable to load from file");
     return NULL;
   }
-  int icon_id = BKE_icon_geom_ensure(geom);
+  const int icon_id = BKE_icon_geom_ensure(geom);
   return PyLong_FromLong(icon_id);
 }
 
diff --git a/source/blender/python/intern/bpy_app_opensubdiv.c b/source/blender/python/intern/bpy_app_opensubdiv.c
index 3f14c4dca57..09cd6201831 100644
--- a/source/blender/python/intern/bpy_app_opensubdiv.c
+++ b/source/blender/python/intern/bpy_app_opensubdiv.c
@@ -63,7 +63,7 @@ static PyObject *make_opensubdiv_info(void)
 #define SetObjItem(obj) PyStructSequence_SET_ITEM(opensubdiv_info, pos++, obj)
 
 #ifdef WITH_OPENSUBDIV
-  int curversion = openSubdiv_getVersionHex();
+  const int curversion = openSubdiv_getVersionHex();
   SetObjItem(PyBool_FromLong(1));
   SetObjItem(PyC_Tuple_Pack_I32(curversion / 10000, (curversion / 100) % 100, curversion % 100));
   SetObjItem(PyUnicode_FromFormat(
diff --git a/source/blender/python/intern/bpy_app_timers.c b/source/blender/python/intern/bpy_app_timers.c
index f1dd8b9e803..af299952b72 100644
--- a/source/blender/python/intern/bpy_app_timers.c
+++ b/source/blender/python/intern/bpy_app_timers.c
@@ -65,7 +65,7 @@ static double py_timer_execute(uintptr_t UNUSED(uuid), void *user_data)
   gilstate = PyGILState_Ensure();
 
   PyObject *py_ret = PyObject_CallObject(function, NULL);
-  double ret = handle_returned_value(function, py_ret);
+  const double ret = handle_returned_value(function, py_ret);
 
   PyGILState_Release(gilstate);
 
@@ -151,7 +151,7 @@ PyDoc_STRVAR(bpy_app_timers_is_registered_doc,
              "   :rtype: bool\n");
 static PyObject *bpy_app_timers_is_registered(PyObject *UNUSED(self), PyObject *function)
 {
-  bool ret = BLI_timer_is_registered((intptr_t)function);
+  const bool ret = BLI_timer_is_registered((intptr_t)function);
   return PyBool_FromLong(ret);
 }
 
diff --git a/source/blender/python/intern/bpy_app_translations.c b/source/blender/python/intern/bpy_app_translations.c
index c152c920453..f95261df6b2 100644
--- a/source/blender/python/intern/bpy_app_translations.c
+++ b/source/blender/python/intern/bpy_app_translations.c
@@ -92,7 +92,7 @@ static GHashKey *_ghashutil_keyalloc(const void *msgctxt, const void *msgid)
 static uint _ghashutil_keyhash(const void *ptr)
 {
   const GHashKey *key = ptr;
-  uint hash = BLI_ghashutil_strhash(key->msgctxt);
+  const uint hash = BLI_ghashutil_strhash(key->msgctxt);
   return hash ^ BLI_ghashutil_strhash(key->msgid);
 }
 
diff --git a/source/blender/python/intern/bpy_capi_utils.c b/source/blender/python/intern/bpy_capi_utils.c
index 27eea80f1f6..8eb44e918d7 100644
--- a/source/blender/python/intern/bpy_capi_utils.c
+++ b/source/blender/python/intern/bpy_capi_utils.c
@@ -51,16 +51,17 @@ void BPy_SetContext(bContext *C)
 char *BPy_enum_as_string(const EnumPropertyItem *item)
 {
   DynStr *dynstr = BLI_dynstr_new();
-  const EnumPropertyItem *e;
-  char *cstring;
 
-  for (e = item; item->identifier; item++) {
+  /* We can't compare with the first element in the array
+   * since it may be a category (without an identifier). */
+  for (bool is_first = true; item->identifier; item++) {
     if (item->identifier[0]) {
-      BLI_dynstr_appendf(dynstr, (e == item) ? "'%s'" : ", '%s'", item->identifier);
+      BLI_dynstr_appendf(dynstr, is_first ? "'%s'" : ", '%s'", item->identifier);
+      is_first = false;
     }
   }
 
-  cstring = BLI_dynstr_get_cstring(dynstr);
+  char *cstring = BLI_dynstr_get_cstring(dynstr);
   BLI_dynstr_free(dynstr);
   return cstring;
 }
diff --git a/source/blender/python/intern/bpy_driver.c b/source/blender/python/intern/bpy_driver.c
index 7fb4b0c469c..4ef685b7987 100644
--- a/source/blender/python/intern/bpy_driver.c
+++ b/source/blender/python/intern/bpy_driver.c
@@ -228,7 +228,7 @@ static void bpy_pydriver_namespace_clear_self(void)
 void BPY_driver_reset(void)
 {
   PyGILState_STATE gilstate;
-  bool use_gil = true; /* !PyC_IsInterpreterActive(); */
+  const bool use_gil = true; /* !PyC_IsInterpreterActive(); */
 
   if (use_gil) {
     gilstate = PyGILState_Ensure();
@@ -594,7 +594,7 @@ float BPY_driver_exec(struct PathResolvedRNA *anim_rna,
 #endif
     {
       /* try to get variable value */
-      float tval = driver_get_variable_value(driver, dvar);
+      const float tval = driver_get_variable_value(driver, dvar);
       driver_arg = PyFloat_FromDouble((double)tval);
     }
 
diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c
index c311041e4cb..bc7318e1a15 100644
--- a/source/blender/python/intern/bpy_interface.c
+++ b/source/blender/python/intern/bpy_interface.c
@@ -25,6 +25,7 @@
  */
 
 #include <Python.h>
+#include <frameobject.h>
 
 #include "MEM_guardedalloc.h"
 
@@ -62,6 +63,8 @@
 #endif
 
 #include "BPY_extern.h"
+#include "BPY_extern_python.h"
+#include "BPY_extern_run.h"
 
 #include "../generic/py_capi_utils.h"
 
@@ -166,7 +169,7 @@ void BPY_text_free_code(Text *text)
 {
   if (text->compiled) {
     PyGILState_STATE gilstate;
-    bool use_gil = !PyC_IsInterpreterActive();
+    const bool use_gil = !PyC_IsInterpreterActive();
 
     if (use_gil) {
       gilstate = PyGILState_Ensure();
@@ -426,192 +429,31 @@ void BPY_python_use_system_env(void)
   py_use_system_env = true;
 }
 
-static void python_script_error_jump_text(struct Text *text)
-{
-  int lineno;
-  int offset;
-  python_script_error_jump(text->id.name + 2, &lineno, &offset);
-  if (lineno != -1) {
-    /* select the line with the error */
-    txt_move_to(text, lineno - 1, INT_MAX, false);
-    txt_move_to(text, lineno - 1, offset, true);
-  }
-}
-
-void BPY_python_backtrace(/* FILE */ void *fp)
+void BPY_python_backtrace(FILE *fp)
 {
   fputs("\n# Python backtrace\n", fp);
-  PyC_StackPrint(fp);
-}
-
-/* super annoying, undo _PyModule_Clear(), bug [#23871] */
-#define PYMODULE_CLEAR_WORKAROUND
-
-#ifdef PYMODULE_CLEAR_WORKAROUND
-/* bad!, we should never do this, but currently only safe way I could find to keep namespace.
- * from being cleared. - campbell */
-typedef struct {
-  PyObject_HEAD PyObject *md_dict;
-  /* omit other values, we only want the dict. */
-} PyModuleObject;
-#endif
-
-/* returns a dummy filename for a textblock so we can tell what file a text block comes from */
-static void bpy_text_filename_get(char *fn, const Main *bmain, size_t fn_len, const Text *text)
-{
-  BLI_snprintf(fn, fn_len, "%s%c%s", ID_BLEND_PATH(bmain, &text->id), SEP, text->id.name + 2);
-}
-
-static bool python_script_exec(
-    bContext *C, const char *fn, struct Text *text, struct ReportList *reports, const bool do_jump)
-{
-  Main *bmain_old = CTX_data_main(C);
-  PyObject *main_mod = NULL;
-  PyObject *py_dict = NULL, *py_result = NULL;
-  PyGILState_STATE gilstate;
-
-  BLI_assert(fn || text);
-
-  if (fn == NULL && text == NULL) {
-    return 0;
-  }
-
-  bpy_context_set(C, &gilstate);
-
-  PyC_MainModule_Backup(&main_mod);
-
-  if (text) {
-    char fn_dummy[FILE_MAXDIR];
-    bpy_text_filename_get(fn_dummy, bmain_old, sizeof(fn_dummy), text);
-
-    if (text->compiled == NULL) { /* if it wasn't already compiled, do it now */
-      char *buf;
-      PyObject *fn_dummy_py;
-
-      fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
-
-      buf = txt_to_buf(text, NULL);
-      text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
-      MEM_freeN(buf);
-
-      Py_DECREF(fn_dummy_py);
-
-      if (PyErr_Occurred()) {
-        if (do_jump) {
-          python_script_error_jump_text(text);
-        }
-        BPY_text_free_code(text);
-      }
-    }
-
-    if (text->compiled) {
-      py_dict = PyC_DefaultNameSpace(fn_dummy);
-      py_result = PyEval_EvalCode(text->compiled, py_dict, py_dict);
-    }
-  }
-  else {
-    FILE *fp = BLI_fopen(fn, "r");
-
-    if (fp) {
-      py_dict = PyC_DefaultNameSpace(fn);
-
-#ifdef _WIN32
-      /* Previously we used PyRun_File to run directly the code on a FILE
-       * object, but as written in the Python/C API Ref Manual, chapter 2,
-       * 'FILE structs for different C libraries can be different and
-       * incompatible'.
-       * So now we load the script file data to a buffer.
-       *
-       * Note on use of 'globals()', it's important not copy the dictionary because
-       * tools may inspect 'sys.modules["__main__"]' for variables defined in the code
-       * where using a copy of 'globals()' causes code execution
-       * to leave the main namespace untouched. see: T51444
-       *
-       * This leaves us with the problem of variables being included,
-       * currently this is worked around using 'dict.__del__' it's ugly but works.
-       */
-      {
-        const char *pystring =
-            "with open(__file__, 'rb') as f:"
-            "exec(compile(f.read(), __file__, 'exec'), globals().__delitem__('f') or globals())";
-
-        fclose(fp);
-
-        py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
-      }
-#else
-      py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
-      fclose(fp);
-#endif
-    }
-    else {
-      PyErr_Format(
-          PyExc_IOError, "Python file \"%s\" could not be opened: %s", fn, strerror(errno));
-      py_result = NULL;
-    }
-  }
-
-  if (!py_result) {
-    if (text) {
-      if (do_jump) {
-        /* ensure text is valid before use, the script may have freed its self */
-        Main *bmain_new = CTX_data_main(C);
-        if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->texts, text) != -1)) {
-          python_script_error_jump_text(text);
-        }
-      }
-    }
-    BPy_errors_to_report(reports);
+  PyThreadState *tstate = PyGILState_GetThisThreadState();
+  if (tstate != NULL && tstate->frame != NULL) {
+    PyFrameObject *frame = tstate->frame;
+    do {
+      const int line = PyCode_Addr2Line(frame->f_code, frame->f_lasti);
+      const char *filename = _PyUnicode_AsString(frame->f_code->co_filename);
+      const char *funcname = _PyUnicode_AsString(frame->f_code->co_name);
+      fprintf(fp, "  File \"%s\", line %d in %s\n", filename, line, funcname);
+    } while ((frame = frame->f_back));
   }
-  else {
-    Py_DECREF(py_result);
-  }
-
-  if (py_dict) {
-#ifdef PYMODULE_CLEAR_WORKAROUND
-    PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItem(PyImport_GetModuleDict(),
-                                                            bpy_intern_str___main__);
-    PyObject *dict_back = mmod->md_dict;
-    /* freeing the module will clear the namespace,
-     * gives problems running classes defined in this namespace being used later. */
-    mmod->md_dict = NULL;
-    Py_DECREF(dict_back);
-#endif
-
-#undef PYMODULE_CLEAR_WORKAROUND
-  }
-
-  PyC_MainModule_Restore(main_mod);
-
-  bpy_context_clear(C, &gilstate);
-
-  return (py_result != NULL);
-}
-
-/* Can run a file or text block */
-bool BPY_execute_filepath(bContext *C, const char *filepath, struct ReportList *reports)
-{
-  return python_script_exec(C, filepath, NULL, reports, false);
-}
-
-bool BPY_execute_text(bContext *C,
-                      struct Text *text,
-                      struct ReportList *reports,
-                      const bool do_jump)
-{
-  return python_script_exec(C, NULL, text, reports, do_jump);
 }
 
 void BPY_DECREF(void *pyob_ptr)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
   Py_DECREF((PyObject *)pyob_ptr);
   PyGILState_Release(gilstate);
 }
 
 void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
   const int do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
   Py_DECREF((PyObject *)pyob_ptr);
   if (do_invalidate) {
@@ -620,177 +462,6 @@ void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
   PyGILState_Release(gilstate);
 }
 
-/**
- * \return success
- */
-bool BPY_execute_string_as_number(bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  double *r_value)
-{
-  PyGILState_STATE gilstate;
-  bool ok = true;
-
-  if (!r_value || !expr) {
-    return -1;
-  }
-
-  if (expr[0] == '\0') {
-    *r_value = 0.0;
-    return ok;
-  }
-
-  bpy_context_set(C, &gilstate);
-
-  ok = PyC_RunString_AsNumber(imports, expr, "<expr as number>", r_value);
-
-  if (ok == false) {
-    if (report_prefix != NULL) {
-      BPy_errors_to_report_ex(CTX_wm_reports(C), report_prefix, false, false);
-    }
-    else {
-      PyErr_Clear();
-    }
-  }
-
-  bpy_context_clear(C, &gilstate);
-
-  return ok;
-}
-
-/**
- * \return success
- */
-bool BPY_execute_string_as_string_and_size(bContext *C,
-                                           const char *imports[],
-                                           const char *expr,
-                                           const char *report_prefix,
-                                           char **r_value,
-                                           size_t *r_value_size)
-{
-  BLI_assert(r_value && expr);
-  PyGILState_STATE gilstate;
-  bool ok = true;
-
-  if (expr[0] == '\0') {
-    *r_value = NULL;
-    return ok;
-  }
-
-  bpy_context_set(C, &gilstate);
-
-  ok = PyC_RunString_AsStringAndSize(imports, expr, "<expr as str>", r_value, r_value_size);
-
-  if (ok == false) {
-    if (report_prefix != NULL) {
-      BPy_errors_to_report_ex(CTX_wm_reports(C), false, false, report_prefix);
-    }
-    else {
-      PyErr_Clear();
-    }
-  }
-
-  bpy_context_clear(C, &gilstate);
-
-  return ok;
-}
-
-bool BPY_execute_string_as_string(bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  char **r_value)
-{
-  size_t value_dummy_size;
-  return BPY_execute_string_as_string_and_size(
-      C, imports, expr, report_prefix, r_value, &value_dummy_size);
-}
-
-/**
- * Support both int and pointers.
- *
- * \return success
- */
-bool BPY_execute_string_as_intptr(bContext *C,
-                                  const char *imports[],
-                                  const char *expr,
-                                  const char *report_prefix,
-                                  intptr_t *r_value)
-{
-  BLI_assert(r_value && expr);
-  PyGILState_STATE gilstate;
-  bool ok = true;
-
-  if (expr[0] == '\0') {
-    *r_value = 0;
-    return ok;
-  }
-
-  bpy_context_set(C, &gilstate);
-
-  ok = PyC_RunString_AsIntPtr(imports, expr, "<expr as intptr>", r_value);
-
-  if (ok == false) {
-    if (report_prefix != NULL) {
-      BPy_errors_to_report_ex(CTX_wm_reports(C), report_prefix, false, false);
-    }
-    else {
-      PyErr_Clear();
-    }
-  }
-
-  bpy_context_clear(C, &gilstate);
-
-  return ok;
-}
-
-bool BPY_execute_string_ex(bContext *C, const char *imports[], const char *expr, bool use_eval)
-{
-  BLI_assert(expr);
-  PyGILState_STATE gilstate;
-  PyObject *main_mod = NULL;
-  PyObject *py_dict, *retval;
-  bool ok = true;
-
-  if (expr[0] == '\0') {
-    return ok;
-  }
-
-  bpy_context_set(C, &gilstate);
-
-  PyC_MainModule_Backup(&main_mod);
-
-  py_dict = PyC_DefaultNameSpace("<blender string>");
-
-  if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
-    Py_DECREF(py_dict);
-    retval = NULL;
-  }
-  else {
-    retval = PyRun_String(expr, use_eval ? Py_eval_input : Py_file_input, py_dict, py_dict);
-  }
-
-  if (retval == NULL) {
-    ok = false;
-    BPy_errors_to_report(CTX_wm_reports(C));
-  }
-  else {
-    Py_DECREF(retval);
-  }
-
-  PyC_MainModule_Restore(main_mod);
-
-  bpy_context_clear(C, &gilstate);
-
-  return ok;
-}
-
-bool BPY_execute_string(bContext *C, const char *imports[], const char *expr)
-{
-  return BPY_execute_string_ex(C, imports, expr, true);
-}
-
 void BPY_modules_load_user(bContext *C)
 {
   PyGILState_STATE gilstate;
@@ -823,7 +494,7 @@ void BPY_modules_load_user(bContext *C)
         }
       }
       else {
-        BPY_execute_text(C, text, NULL, false);
+        BPY_run_text(C, text, NULL, false);
 
         /* Check if the script loaded a new file. */
         if (bmain != CTX_data_main(C)) {
@@ -838,7 +509,7 @@ void BPY_modules_load_user(bContext *C)
 int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
 {
   PyGILState_STATE gilstate;
-  bool use_gil = !PyC_IsInterpreterActive();
+  const bool use_gil = !PyC_IsInterpreterActive();
 
   PyObject *pyctx;
   PyObject *item;
@@ -873,7 +544,7 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *
       PyErr_Clear();
     }
     else {
-      int len = PySequence_Fast_GET_SIZE(seq_fast);
+      const int len = PySequence_Fast_GET_SIZE(seq_fast);
       PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
       int i;
 
diff --git a/source/blender/python/intern/bpy_interface_run.c b/source/blender/python/intern/bpy_interface_run.c
new file mode 100644
index 00000000000..a7593ae7d79
--- /dev/null
+++ b/source/blender/python/intern/bpy_interface_run.c
@@ -0,0 +1,422 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup pythonintern
+ */
+
+#include <stdio.h>
+
+#include <Python.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_fileops.h"
+#include "BLI_listbase.h"
+#include "BLI_path_util.h"
+#include "BLI_string.h"
+
+#include "BKE_context.h"
+#include "BKE_main.h"
+#include "BKE_text.h"
+
+#include "DNA_text_types.h"
+
+#include "BPY_extern.h"
+#include "BPY_extern_run.h"
+
+#include "bpy_capi_utils.h"
+#include "bpy_intern_string.h"
+#include "bpy_traceback.h"
+
+#include "../generic/py_capi_utils.h"
+
+/* -------------------------------------------------------------------- */
+/** \name Private Utilities
+ * \{ */
+
+static void python_script_error_jump_text(Text *text)
+{
+  int lineno;
+  int offset;
+  python_script_error_jump(text->id.name + 2, &lineno, &offset);
+  if (lineno != -1) {
+    /* select the line with the error */
+    txt_move_to(text, lineno - 1, INT_MAX, false);
+    txt_move_to(text, lineno - 1, offset, true);
+  }
+}
+
+/* returns a dummy filename for a textblock so we can tell what file a text block comes from */
+static void bpy_text_filename_get(char *fn, const Main *bmain, size_t fn_len, const Text *text)
+{
+  BLI_snprintf(fn, fn_len, "%s%c%s", ID_BLEND_PATH(bmain, &text->id), SEP, text->id.name + 2);
+}
+
+/* Very annoying! Undo #_PyModule_Clear(), see T23871. */
+#define PYMODULE_CLEAR_WORKAROUND
+
+#ifdef PYMODULE_CLEAR_WORKAROUND
+/* bad!, we should never do this, but currently only safe way I could find to keep namespace.
+ * from being cleared. - campbell */
+typedef struct {
+  PyObject_HEAD PyObject *md_dict;
+  /* omit other values, we only want the dict. */
+} PyModuleObject;
+#endif
+
+static bool python_script_exec(
+    bContext *C, const char *fn, struct Text *text, struct ReportList *reports, const bool do_jump)
+{
+  Main *bmain_old = CTX_data_main(C);
+  PyObject *main_mod = NULL;
+  PyObject *py_dict = NULL, *py_result = NULL;
+  PyGILState_STATE gilstate;
+
+  BLI_assert(fn || text);
+
+  if (fn == NULL && text == NULL) {
+    return 0;
+  }
+
+  bpy_context_set(C, &gilstate);
+
+  PyC_MainModule_Backup(&main_mod);
+
+  if (text) {
+    char fn_dummy[FILE_MAXDIR];
+    bpy_text_filename_get(fn_dummy, bmain_old, sizeof(fn_dummy), text);
+
+    if (text->compiled == NULL) { /* if it wasn't already compiled, do it now */
+      char *buf;
+      PyObject *fn_dummy_py;
+
+      fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);
+
+      buf = txt_to_buf(text, NULL);
+      text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
+      MEM_freeN(buf);
+
+      Py_DECREF(fn_dummy_py);
+
+      if (PyErr_Occurred()) {
+        if (do_jump) {
+          python_script_error_jump_text(text);
+        }
+        BPY_text_free_code(text);
+      }
+    }
+
+    if (text->compiled) {
+      py_dict = PyC_DefaultNameSpace(fn_dummy);
+      py_result = PyEval_EvalCode(text->compiled, py_dict, py_dict);
+    }
+  }
+  else {
+    FILE *fp = BLI_fopen(fn, "r");
+
+    if (fp) {
+      py_dict = PyC_DefaultNameSpace(fn);
+
+#ifdef _WIN32
+      /* Previously we used PyRun_File to run directly the code on a FILE
+       * object, but as written in the Python/C API Ref Manual, chapter 2,
+       * 'FILE structs for different C libraries can be different and
+       * incompatible'.
+       * So now we load the script file data to a buffer.
+       *
+       * Note on use of 'globals()', it's important not copy the dictionary because
+       * tools may inspect 'sys.modules["__main__"]' for variables defined in the code
+       * where using a copy of 'globals()' causes code execution
+       * to leave the main namespace untouched. see: T51444
+       *
+       * This leaves us with the problem of variables being included,
+       * currently this is worked around using 'dict.__del__' it's ugly but works.
+       */
+      {
+        const char *pystring =
+            "with open(__file__, 'rb') as f:"
+            "exec(compile(f.read(), __file__, 'exec'), globals().__delitem__('f') or globals())";
+
+        fclose(fp);
+
+        py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);
+      }
+#else
+      py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
+      fclose(fp);
+#endif
+    }
+    else {
+      PyErr_Format(
+          PyExc_IOError, "Python file \"%s\" could not be opened: %s", fn, strerror(errno));
+      py_result = NULL;
+    }
+  }
+
+  if (!py_result) {
+    if (text) {
+      if (do_jump) {
+        /* ensure text is valid before use, the script may have freed its self */
+        Main *bmain_new = CTX_data_main(C);
+        if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->texts, text) != -1)) {
+          python_script_error_jump_text(text);
+        }
+      }
+    }
+    BPy_errors_to_report(reports);
+  }
+  else {
+    Py_DECREF(py_result);
+  }
+
+  if (py_dict) {
+#ifdef PYMODULE_CLEAR_WORKAROUND
+    PyModuleObject *mmod = (PyModuleObject *)PyDict_GetItem(PyImport_GetModuleDict(),
+                                                            bpy_intern_str___main__);
+    PyObject *dict_back = mmod->md_dict;
+    /* freeing the module will clear the namespace,
+     * gives problems running classes defined in this namespace being used later. */
+    mmod->md_dict = NULL;
+    Py_DECREF(dict_back);
+#endif
+
+#undef PYMODULE_CLEAR_WORKAROUND
+  }
+
+  PyC_MainModule_Restore(main_mod);
+
+  bpy_context_clear(C, &gilstate);
+
+  return (py_result != NULL);
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Run Text / Filename / String
+ * \{ */
+
+/* Can run a file or text block */
+bool BPY_run_filepath(bContext *C, const char *filepath, struct ReportList *reports)
+{
+  return python_script_exec(C, filepath, NULL, reports, false);
+}
+
+bool BPY_run_text(bContext *C, struct Text *text, struct ReportList *reports, const bool do_jump)
+{
+  return python_script_exec(C, NULL, text, reports, do_jump);
+}
+
+/**
+ * \param mode: Passed to #PyRun_String, matches Python's `compile` functions mode argument.
+ * #Py_eval_input for `eval`, #Py_file_input for `exec`.
+ */
+static bool bpy_run_string_impl(bContext *C,
+                                const char *imports[],
+                                const char *expr,
+                                const int mode)
+{
+  BLI_assert(expr);
+  PyGILState_STATE gilstate;
+  PyObject *main_mod = NULL;
+  PyObject *py_dict, *retval;
+  bool ok = true;
+
+  if (expr[0] == '\0') {
+    return ok;
+  }
+
+  bpy_context_set(C, &gilstate);
+
+  PyC_MainModule_Backup(&main_mod);
+
+  py_dict = PyC_DefaultNameSpace("<blender string>");
+
+  if (imports && (!PyC_NameSpace_ImportArray(py_dict, imports))) {
+    Py_DECREF(py_dict);
+    retval = NULL;
+  }
+  else {
+    retval = PyRun_String(expr, mode, py_dict, py_dict);
+  }
+
+  if (retval == NULL) {
+    ok = false;
+    BPy_errors_to_report(CTX_wm_reports(C));
+  }
+  else {
+    Py_DECREF(retval);
+  }
+
+  PyC_MainModule_Restore(main_mod);
+
+  bpy_context_clear(C, &gilstate);
+
+  return ok;
+}
+
+/**
+ * Run an expression, matches: `exec(compile(..., "eval"))`
+ */
+bool BPY_run_string_eval(bContext *C, const char *imports[], const char *expr)
+{
+  return bpy_run_string_impl(C, imports, expr, Py_eval_input);
+}
+
+/**
+ * Run an entire script, matches: `exec(compile(..., "exec"))`
+ */
+bool BPY_run_string_exec(bContext *C, const char *imports[], const char *expr)
+{
+  return bpy_run_string_impl(C, imports, expr, Py_file_input);
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Run Python & Evaluate Utilities
+ *
+ * Return values as plain C types, useful to run Python scripts
+ * in code that doesn't deal with Python data-types.
+ * \{ */
+
+/**
+ * \return success
+ */
+bool BPY_run_string_as_number(bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              double *r_value)
+{
+  PyGILState_STATE gilstate;
+  bool ok = true;
+
+  if (!r_value || !expr) {
+    return -1;
+  }
+
+  if (expr[0] == '\0') {
+    *r_value = 0.0;
+    return ok;
+  }
+
+  bpy_context_set(C, &gilstate);
+
+  ok = PyC_RunString_AsNumber(imports, expr, "<expr as number>", r_value);
+
+  if (ok == false) {
+    if (report_prefix != NULL) {
+      BPy_errors_to_report_ex(CTX_wm_reports(C), report_prefix, false, false);
+    }
+    else {
+      PyErr_Clear();
+    }
+  }
+
+  bpy_context_clear(C, &gilstate);
+
+  return ok;
+}
+
+/**
+ * \return success
+ */
+bool BPY_run_string_as_string_and_size(bContext *C,
+                                       const char *imports[],
+                                       const char *expr,
+                                       const char *report_prefix,
+                                       char **r_value,
+                                       size_t *r_value_size)
+{
+  BLI_assert(r_value && expr);
+  PyGILState_STATE gilstate;
+  bool ok = true;
+
+  if (expr[0] == '\0') {
+    *r_value = NULL;
+    return ok;
+  }
+
+  bpy_context_set(C, &gilstate);
+
+  ok = PyC_RunString_AsStringAndSize(imports, expr, "<expr as str>", r_value, r_value_size);
+
+  if (ok == false) {
+    if (report_prefix != NULL) {
+      BPy_errors_to_report_ex(CTX_wm_reports(C), false, false, report_prefix);
+    }
+    else {
+      PyErr_Clear();
+    }
+  }
+
+  bpy_context_clear(C, &gilstate);
+
+  return ok;
+}
+
+bool BPY_run_string_as_string(bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              char **r_value)
+{
+  size_t value_dummy_size;
+  return BPY_run_string_as_string_and_size(
+      C, imports, expr, report_prefix, r_value, &value_dummy_size);
+}
+
+/**
+ * Support both int and pointers.
+ *
+ * \return success
+ */
+bool BPY_run_string_as_intptr(bContext *C,
+                              const char *imports[],
+                              const char *expr,
+                              const char *report_prefix,
+                              intptr_t *r_value)
+{
+  BLI_assert(r_value && expr);
+  PyGILState_STATE gilstate;
+  bool ok = true;
+
+  if (expr[0] == '\0') {
+    *r_value = 0;
+    return ok;
+  }
+
+  bpy_context_set(C, &gilstate);
+
+  ok = PyC_RunString_AsIntPtr(imports, expr, "<expr as intptr>", r_value);
+
+  if (ok == false) {
+    if (report_prefix != NULL) {
+      BPy_errors_to_report_ex(CTX_wm_reports(C), report_prefix, false, false);
+    }
+    else {
+      PyErr_Clear();
+    }
+  }
+
+  bpy_context_clear(C, &gilstate);
+
+  return ok;
+}
+
+/** \} */
diff --git a/source/blender/python/intern/bpy_library_load.c b/source/blender/python/intern/bpy_library_load.c
index bcf13b1d88f..bdad4d03ae7 100644
--- a/source/blender/python/intern/bpy_library_load.c
+++ b/source/blender/python/intern/bpy_library_load.c
@@ -321,7 +321,7 @@ static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
 {
   Main *bmain = CTX_data_main(BPy_GetContext());
   Main *mainl = NULL;
-  int err = 0;
+  const int err = 0;
   const bool do_append = ((self->flag & FILE_LINK) == 0);
 
   BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, true);
@@ -338,7 +338,7 @@ static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
         // printf("lib: %s\n", name_plural);
         if (ls && PyList_Check(ls)) {
           /* loop */
-          Py_ssize_t size = PyList_GET_SIZE(ls);
+          const Py_ssize_t size = PyList_GET_SIZE(ls);
           Py_ssize_t i;
 
           for (i = 0; i < size; i++) {
@@ -423,7 +423,7 @@ static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
         const char *name_plural = BKE_idtype_idcode_to_name_plural(idcode);
         PyObject *ls = PyDict_GetItemString(self->dict, name_plural);
         if (ls && PyList_Check(ls)) {
-          Py_ssize_t size = PyList_GET_SIZE(ls);
+          const Py_ssize_t size = PyList_GET_SIZE(ls);
           Py_ssize_t i;
           PyObject *item;
 
diff --git a/source/blender/python/intern/bpy_msgbus.c b/source/blender/python/intern/bpy_msgbus.c
index 45c5aba1e3e..3739f56dc79 100644
--- a/source/blender/python/intern/bpy_msgbus.c
+++ b/source/blender/python/intern/bpy_msgbus.c
@@ -192,7 +192,7 @@ static void bpy_msgbus_notify(bContext *C,
 static void bpy_msgbus_subscribe_value_free_data(struct wmMsgSubscribeKey *UNUSED(msg_key),
                                                  struct wmMsgSubscribeValue *msg_val)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
   Py_DECREF(msg_val->owner);
   Py_DECREF(msg_val->user_data);
   PyGILState_Release(gilstate);
diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c
index 4b2b5f129a7..6d86d788644 100644
--- a/source/blender/python/intern/bpy_operator.c
+++ b/source/blender/python/intern/bpy_operator.c
@@ -227,7 +227,14 @@ static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
 
   context_dict_back = CTX_py_dict_get(C);
 
-  CTX_py_dict_set(C, (void *)context_dict);
+  /**
+   * It might be that there is already a Python context override. We don't want to remove that
+   * except when this operator call sets a new override explicitly. This is necessary so that
+   * called operator runs in the same context as the calling code by default.
+   */
+  if (context_dict != NULL) {
+    CTX_py_dict_set(C, (void *)context_dict);
+  }
   Py_XINCREF(context_dict); /* so we done loose it */
 
   if (WM_operator_poll_context((bContext *)C, ot, context) == false) {
@@ -429,12 +436,22 @@ static PyObject *pyop_getrna_type(PyObject *UNUSED(self), PyObject *value)
   return (PyObject *)pyrna;
 }
 
+static PyObject *pyop_get_bl_options(PyObject *UNUSED(self), PyObject *value)
+{
+  wmOperatorType *ot;
+  if ((ot = ot_lookup_from_py_string(value, "get_bl_options")) == NULL) {
+    return NULL;
+  }
+  return pyrna_enum_bitfield_to_py(rna_enum_operator_type_flag_items, ot->flag);
+}
+
 static struct PyMethodDef bpy_ops_methods[] = {
     {"poll", (PyCFunction)pyop_poll, METH_VARARGS, NULL},
     {"call", (PyCFunction)pyop_call, METH_VARARGS, NULL},
     {"as_string", (PyCFunction)pyop_as_string, METH_VARARGS, NULL},
     {"dir", (PyCFunction)pyop_dir, METH_NOARGS, NULL},
     {"get_rna_type", (PyCFunction)pyop_getrna_type, METH_O, NULL},
+    {"get_bl_options", (PyCFunction)pyop_get_bl_options, METH_O, NULL},
     {"macro_define", (PyCFunction)PYOP_wrap_macro_define, METH_VARARGS, NULL},
     {NULL, NULL, 0, NULL},
 };
diff --git a/source/blender/python/intern/bpy_props.c b/source/blender/python/intern/bpy_props.c
index 66c67ca061c..859f0027f14 100644
--- a/source/blender/python/intern/bpy_props.c
+++ b/source/blender/python/intern/bpy_props.c
@@ -351,7 +351,7 @@ static bool bpy_prop_boolean_get_cb(struct PointerRNA *ptr, struct PropertyRNA *
     value = false;
   }
   else {
-    int value_i = PyC_Long_AsBool(ret);
+    const int value_i = PyC_Long_AsBool(ret);
 
     if (value_i == -1 && PyErr_Occurred()) {
       PyC_Err_PrintWithFunc(py_func);
@@ -443,7 +443,7 @@ static bool bpy_prop_poll_cb(struct PointerRNA *self,
   PyObject *ret;
   bool result;
   const int is_write_ok = pyrna_write_check();
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
 
   BLI_assert(self != NULL);
 
@@ -560,7 +560,7 @@ static void bpy_prop_boolean_array_set_cb(struct PointerRNA *ptr,
   PyGILState_STATE gilstate;
   bool use_gil;
   const bool is_write_ok = pyrna_write_check();
-  int len = RNA_property_array_length(ptr, prop);
+  const int len = RNA_property_array_length(ptr, prop);
 
   BLI_assert(py_data != NULL);
 
@@ -804,7 +804,7 @@ static void bpy_prop_int_array_set_cb(struct PointerRNA *ptr,
   PyGILState_STATE gilstate;
   bool use_gil;
   const bool is_write_ok = pyrna_write_check();
-  int len = RNA_property_array_length(ptr, prop);
+  const int len = RNA_property_array_length(ptr, prop);
 
   BLI_assert(py_data != NULL);
 
@@ -1048,7 +1048,7 @@ static void bpy_prop_float_array_set_cb(struct PointerRNA *ptr,
   PyGILState_STATE gilstate;
   bool use_gil;
   const bool is_write_ok = pyrna_write_check();
-  int len = RNA_property_array_length(ptr, prop);
+  const int len = RNA_property_array_length(ptr, prop);
 
   BLI_assert(py_data != NULL);
 
diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c
index 955a24bc880..a3ded8813ac 100644
--- a/source/blender/python/intern/bpy_rna.c
+++ b/source/blender/python/intern/bpy_rna.c
@@ -464,7 +464,7 @@ static int mathutils_rna_vector_set(BaseMathObject *bmo, int subtype)
   if (subtype == MATHUTILS_CB_SUBTYPE_EUL) {
     EulerObject *eul = (EulerObject *)bmo;
     PropertyRNA *prop_eul_order = NULL;
-    short order = pyrna_rotation_euler_order_get(&self->ptr, eul->order, &prop_eul_order);
+    const short order = pyrna_rotation_euler_order_get(&self->ptr, eul->order, &prop_eul_order);
     if (order != eul->order) {
       RNA_property_enum_set(&self->ptr, prop_eul_order, eul->order);
       if (RNA_property_update_check(prop_eul_order)) {
@@ -599,7 +599,7 @@ static short pyrna_rotation_euler_order_get(PointerRNA *ptr,
   }
 
   if (*r_prop_eul_order) {
-    short order = RNA_property_enum_get(ptr, *r_prop_eul_order);
+    const short order = RNA_property_enum_get(ptr, *r_prop_eul_order);
     /* Could be quat or axisangle. */
     if (order >= EULER_ORDER_XYZ && order <= EULER_ORDER_ZYX) {
       return order;
@@ -714,7 +714,8 @@ PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop)
             /* Attempt to get order,
              * only needed for thick types since wrapped with update via callbacks. */
             PropertyRNA *prop_eul_order = NULL;
-            short order = pyrna_rotation_euler_order_get(ptr, EULER_ORDER_XYZ, &prop_eul_order);
+            const short order = pyrna_rotation_euler_order_get(
+                ptr, EULER_ORDER_XYZ, &prop_eul_order);
 
             ret = Euler_CreatePyObject(NULL, order, NULL); /* TODO, get order from RNA. */
             RNA_property_float_get_array(ptr, prop, ((EulerObject *)ret)->eul);
@@ -1725,7 +1726,7 @@ static int pyrna_py_to_prop(
       }
       case PROP_INT: {
         int overflow;
-        long param = PyLong_AsLongAndOverflow(value, &overflow);
+        const long param = PyLong_AsLongAndOverflow(value, &overflow);
         if (overflow || (param > INT_MAX) || (param < INT_MIN)) {
           PyErr_Format(PyExc_ValueError,
                        "%.200s %.200s.%.200s value not in 'int' range "
@@ -1757,7 +1758,7 @@ static int pyrna_py_to_prop(
         break;
       }
       case PROP_FLOAT: {
-        float param = PyFloat_AsDouble(value);
+        const float param = PyFloat_AsDouble(value);
         if (PyErr_Occurred()) {
           PyErr_Format(PyExc_TypeError,
                        "%.200s %.200s.%.200s expected a float type, not %.200s",
@@ -1935,8 +1936,8 @@ static int pyrna_py_to_prop(
         PyObject *value_new = NULL;
 
         StructRNA *ptr_type = RNA_property_pointer_type(ptr, prop);
-        int flag = RNA_property_flag(prop);
-        int flag_parameter = RNA_parameter_flag(prop);
+        const int flag = RNA_property_flag(prop);
+        const int flag_parameter = RNA_parameter_flag(prop);
 
         /* This is really nasty! Done so we can fake the operator having direct properties, eg:
          * layout.prop(self, "filepath")
@@ -2075,7 +2076,7 @@ static int pyrna_py_to_prop(
             BKE_reports_init(&reports, RPT_STORE);
             RNA_property_pointer_set(
                 ptr, prop, value == Py_None ? PointerRNA_NULL : param->ptr, &reports);
-            int err = (BPy_reports_to_error(&reports, PyExc_RuntimeError, true));
+            const int err = (BPy_reports_to_error(&reports, PyExc_RuntimeError, true));
             if (err == -1) {
               Py_XDECREF(value_new);
               return -1;
@@ -2233,7 +2234,7 @@ static int pyrna_py_to_prop_array_index(BPy_PropertyArrayRNA *self, int index, P
     /* See if we can coerce into a Python type - 'PropertyType'. */
     switch (RNA_property_type(prop)) {
       case PROP_BOOLEAN: {
-        int param = PyC_Long_AsBool(value);
+        const int param = PyC_Long_AsBool(value);
 
         if (param == -1) {
           /* Error is set. */
@@ -2698,7 +2699,7 @@ static PyObject *pyrna_prop_collection_subscript(BPy_PropertyRNA *self, PyObject
     return pyrna_prop_collection_subscript_str(self, _PyUnicode_AsString(key));
   }
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return NULL;
     }
@@ -2732,7 +2733,7 @@ static PyObject *pyrna_prop_collection_subscript(BPy_PropertyRNA *self, PyObject
 
     if (start < 0 || stop < 0) {
       /* Only get the length for negative values. */
-      Py_ssize_t len = (Py_ssize_t)RNA_property_collection_length(&self->ptr, self->prop);
+      const Py_ssize_t len = (Py_ssize_t)RNA_property_collection_length(&self->ptr, self->prop);
       if (start < 0) {
         start += len;
       }
@@ -2827,7 +2828,7 @@ static int pyrna_prop_collection_ass_subscript(BPy_PropertyRNA *self,
   else
 #endif
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return -1;
     }
@@ -2899,7 +2900,7 @@ static PyObject *pyrna_prop_array_subscript(BPy_PropertyArrayRNA *self, PyObject
   else
 #endif
   if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       return NULL;
     }
@@ -2919,11 +2920,11 @@ static PyObject *pyrna_prop_array_subscript(BPy_PropertyArrayRNA *self, PyObject
     if (key_slice->start == Py_None && key_slice->stop == Py_None) {
       /* Note: no significant advantage with optimizing [:] slice as with collections,
        * but include here for consistency with collection slice func */
-      Py_ssize_t len = (Py_ssize_t)pyrna_prop_array_length(self);
+      const Py_ssize_t len = (Py_ssize_t)pyrna_prop_array_length(self);
       return pyrna_prop_array_subscript_slice(self, &self->ptr, self->prop, 0, len, len);
     }
 
-    int len = pyrna_prop_array_length(self);
+    const int len = pyrna_prop_array_length(self);
     Py_ssize_t start, stop, slicelength;
 
     if (PySlice_GetIndicesEx(key, len, &start, &stop, &step, &slicelength) < 0) {
@@ -3055,7 +3056,7 @@ static int prop_subscript_ass_array_slice__bool_recursive(PyObject **value_items
   BLI_assert(totdim == 1);
   int i;
   for (i = 0; i != length; i++) {
-    int v = PyLong_AsLong(value_items[i]);
+    const int v = PyLong_AsLong(value_items[i]);
     value[i] = v;
   }
   return i;
@@ -3097,7 +3098,7 @@ static int prop_subscript_ass_array_slice(PointerRNA *ptr,
   }
 
   int dimsize[3];
-  int totdim = RNA_property_array_dimension(ptr, prop, dimsize);
+  const int totdim = RNA_property_array_dimension(ptr, prop, dimsize);
   if (totdim > 1) {
     BLI_assert(dimsize[arraydim] == length);
   }
@@ -3247,7 +3248,7 @@ static int pyrna_prop_array_ass_subscript(BPy_PropertyArrayRNA *self,
   }
 
   else if (PyIndex_Check(key)) {
-    Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
+    const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
     if (i == -1 && PyErr_Occurred()) {
       ret = -1;
     }
@@ -3256,7 +3257,7 @@ static int pyrna_prop_array_ass_subscript(BPy_PropertyArrayRNA *self,
     }
   }
   else if (PySlice_Check(key)) {
-    Py_ssize_t len = pyrna_prop_array_length(self);
+    const Py_ssize_t len = pyrna_prop_array_length(self);
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(key, len, &start, &stop, &step, &slicelength) < 0) {
@@ -4249,7 +4250,7 @@ static PyObject *pyrna_struct_getattro(BPy_StructRNA *self, PyObject *pyname)
       ListBase newlb;
       short newtype;
 
-      int done = CTX_data_get(C, name, &newptr, &newlb, &newtype);
+      const int done = CTX_data_get(C, name, &newptr, &newlb, &newtype);
 
       if (done == 1) { /* Found. */
         switch (newtype) {
@@ -4401,7 +4402,7 @@ static int pyrna_struct_meta_idprop_setattro(PyObject *cls, PyObject *attr, PyOb
   if (value) {
     /* Check if the value is a property. */
     if (is_deferred_prop) {
-      int ret = deferred_register_prop(srna, attr, value);
+      const int ret = deferred_register_prop(srna, attr, value);
       if (ret == -1) {
         /* Error set. */
         return ret;
@@ -4471,7 +4472,7 @@ static int pyrna_struct_setattro(BPy_StructRNA *self, PyObject *pyname, PyObject
     ListBase newlb;
     short newtype;
 
-    int done = CTX_data_get(C, name, &newptr, &newlb, &newtype);
+    const int done = CTX_data_get(C, name, &newptr, &newlb, &newtype);
 
     if (done == 1) {
       PyErr_Format(
@@ -4646,7 +4647,7 @@ static PyObject *pyrna_prop_collection_idprop_add(BPy_PropertyRNA *self)
 
 static PyObject *pyrna_prop_collection_idprop_remove(BPy_PropertyRNA *self, PyObject *value)
 {
-  int key = PyLong_AsLong(value);
+  const int key = PyLong_AsLong(value);
 
 #ifdef USE_PEDANTIC_WRITE
   if (rna_disallow_writes && rna_id_write_error(&self->ptr, NULL)) {
@@ -5172,7 +5173,7 @@ static int foreach_parse_args(BPy_PropertyRNA *self,
 
 static bool foreach_compat_buffer(RawPropertyType raw_type, int attr_signed, const char *format)
 {
-  char f = format ? *format : 'B'; /* B is assumed when not set */
+  const char f = format ? *format : 'B'; /* B is assumed when not set */
 
   switch (raw_type) {
     case PROP_RAW_CHAR:
@@ -5400,7 +5401,7 @@ static PyObject *pyprop_array_foreach_getset(BPy_PropertyArrayRNA *self,
   PyObject *item = NULL;
   Py_ssize_t i, seq_size, size;
   void *array = NULL;
-  PropertyType prop_type = RNA_property_type(self->prop);
+  const PropertyType prop_type = RNA_property_type(self->prop);
 
   /* Get/set both take the same args currently. */
   PyObject *seq;
@@ -5498,7 +5499,7 @@ static PyObject *pyprop_array_foreach_getset(BPy_PropertyArrayRNA *self,
     }
   }
   else {
-    char f = buf.format ? buf.format[0] : 0;
+    const char f = buf.format ? buf.format[0] : 0;
     if ((prop_type == PROP_INT && (buf.itemsize != sizeof(int) || (f != 'l' && f != 'i'))) ||
         (prop_type == PROP_FLOAT && (buf.itemsize != sizeof(float) || f != 'f'))) {
       PyBuffer_Release(&buf);
@@ -8030,7 +8031,7 @@ static int rna_function_arg_count(FunctionRNA *func, int *min_count)
   const ListBase *lb = RNA_function_defined_parameters(func);
   PropertyRNA *parm;
   Link *link;
-  int flag = RNA_function_flag(func);
+  const int flag = RNA_function_flag(func);
   const bool is_staticmethod = (flag & FUNC_NO_SELF) && !(flag & FUNC_USE_SELF_TYPE);
   int count = is_staticmethod ? 0 : 1;
   bool done_min_count = false;
@@ -8273,7 +8274,7 @@ static int bpy_class_call(bContext *C, PointerRNA *ptr, FunctionRNA *func, Param
   ParameterIterator iter;
   PointerRNA funcptr;
   int err = 0, i, ret_len = 0, arg_count;
-  int flag = RNA_function_flag(func);
+  const int flag = RNA_function_flag(func);
   const bool is_staticmethod = (flag & FUNC_NO_SELF) && !(flag & FUNC_USE_SELF_TYPE);
   const bool is_classmethod = (flag & FUNC_NO_SELF) && (flag & FUNC_USE_SELF_TYPE);
 
@@ -9015,7 +9016,7 @@ void pyrna_struct_type_extend_capi(struct StructRNA *srna,
         py_method = PyCFunction_New(method, NULL);
       }
 
-      int err = PyDict_SetItemString(dict, method->ml_name, py_method);
+      const int err = PyDict_SetItemString(dict, method->ml_name, py_method);
       Py_DECREF(py_method);
       BLI_assert(!(err < 0));
       UNUSED_VARS_NDEBUG(err);
diff --git a/source/blender/python/intern/bpy_rna_anim.c b/source/blender/python/intern/bpy_rna_anim.c
index ae19f89c348..1d52706c5f9 100644
--- a/source/blender/python/intern/bpy_rna_anim.c
+++ b/source/blender/python/intern/bpy_rna_anim.c
@@ -131,7 +131,7 @@ static int pyrna_struct_anim_args_parse_ex(PointerRNA *ptr,
       }
     }
     else {
-      int array_len = RNA_property_array_length(&r_ptr, prop);
+      const int array_len = RNA_property_array_length(&r_ptr, prop);
       if ((*r_index) < -1 || (*r_index) >= array_len) {
         PyErr_Format(PyExc_TypeError,
                      "%.200s index out of range \"%s\", given %d, array length is %d",
@@ -316,7 +316,7 @@ PyObject *pyrna_struct_keyframe_insert(BPy_StructRNA *self, PyObject *args, PyOb
   int index = -1;
   float cfra = FLT_MAX;
   const char *group_name = NULL;
-  char keytype = BEZT_KEYTYPE_KEYFRAME; /* XXX: Expose this as a one-off option... */
+  const char keytype = BEZT_KEYTYPE_KEYFRAME; /* XXX: Expose this as a one-off option... */
   int options = 0;
 
   PYRNA_STRUCT_CHECK_OBJ(self);
diff --git a/source/blender/python/intern/bpy_rna_array.c b/source/blender/python/intern/bpy_rna_array.c
index 66e07d556a6..cb3fe9cb600 100644
--- a/source/blender/python/intern/bpy_rna_array.c
+++ b/source/blender/python/intern/bpy_rna_array.c
@@ -361,7 +361,7 @@ static int validate_array(PyObject *rvalue,
                           const char *error_prefix)
 {
   int dimsize[MAX_ARRAY_DIMENSION];
-  int totdim = RNA_property_array_dimension(ptr, prop, dimsize);
+  const int totdim = RNA_property_array_dimension(ptr, prop, dimsize);
 
   /* validate type first because length validation may modify property array length */
 
@@ -466,7 +466,7 @@ static char *copy_values(PyObject *seq,
                          const ItemConvert_FuncArg *convert_item,
                          RNA_SetIndexFunc rna_set_index)
 {
-  int totdim = RNA_property_array_dimension(ptr, prop, NULL);
+  const int totdim = RNA_property_array_dimension(ptr, prop, NULL);
   const Py_ssize_t seq_size = PySequence_Size(seq);
   Py_ssize_t i;
 
@@ -487,7 +487,7 @@ static char *copy_values(PyObject *seq,
   if (dim == 0) {
     if (MatrixObject_Check(seq)) {
       MatrixObject *pymat = (MatrixObject *)seq;
-      size_t allocsize = pymat->num_col * pymat->num_row * sizeof(float);
+      const size_t allocsize = pymat->num_col * pymat->num_row * sizeof(float);
 
       /* read callback already done by validate */
       /* since this is the first iteration we can assume data is allocated */
@@ -993,7 +993,7 @@ PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop)
 /* TODO, multi-dimensional arrays */
 int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
 {
-  int len = RNA_property_array_length(ptr, prop);
+  const int len = RNA_property_array_length(ptr, prop);
   int type;
   int i;
 
@@ -1011,7 +1011,7 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
 
   switch (type) {
     case PROP_FLOAT: {
-      float value_f = PyFloat_AsDouble(value);
+      const float value_f = PyFloat_AsDouble(value);
       if (value_f == -1 && PyErr_Occurred()) {
         PyErr_Clear();
         return 0;
@@ -1044,7 +1044,7 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
       break;
     }
     case PROP_INT: {
-      int value_i = PyC_Long_AsI32(value);
+      const int value_i = PyC_Long_AsI32(value);
       if (value_i == -1 && PyErr_Occurred()) {
         PyErr_Clear();
         return 0;
@@ -1077,7 +1077,7 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
       break;
     }
     case PROP_BOOLEAN: {
-      int value_i = PyC_Long_AsBool(value);
+      const int value_i = PyC_Long_AsBool(value);
       if (value_i == -1 && PyErr_Occurred()) {
         PyErr_Clear();
         return 0;
diff --git a/source/blender/python/intern/bpy_rna_callback.c b/source/blender/python/intern/bpy_rna_callback.c
index 976b8a65ac7..2f8be0c44e0 100644
--- a/source/blender/python/intern/bpy_rna_callback.c
+++ b/source/blender/python/intern/bpy_rna_callback.c
@@ -84,7 +84,7 @@ static void cb_region_draw(const bContext *C, ARegion *UNUSED(region), void *cus
 static PyObject *PyC_Tuple_CopySized(PyObject *src, int len_dst)
 {
   PyObject *dst = PyTuple_New(len_dst);
-  int len_src = PyTuple_GET_SIZE(src);
+  const int len_src = PyTuple_GET_SIZE(src);
   BLI_assert(len_src <= len_dst);
   for (int i = 0; i < len_src; i++) {
     PyObject *item = PyTuple_GET_ITEM(src, i);
diff --git a/source/blender/python/intern/bpy_rna_driver.c b/source/blender/python/intern/bpy_rna_driver.c
index 9240e34bbab..3bddd0ad8c0 100644
--- a/source/blender/python/intern/bpy_rna_driver.c
+++ b/source/blender/python/intern/bpy_rna_driver.c
@@ -57,7 +57,7 @@ PyObject *pyrna_driver_get_variable_value(struct ChannelDriver *driver, struct D
       }
       else {
         /* object & property */
-        PropertyType type = RNA_property_type(prop);
+        const PropertyType type = RNA_property_type(prop);
         if (type == PROP_ENUM) {
           /* Note that enum's are converted to strings by default,
            * we want to avoid that, see: T52213 */
diff --git a/source/blender/python/intern/bpy_rna_gizmo.c b/source/blender/python/intern/bpy_rna_gizmo.c
index 4ef718ef023..575824e8a86 100644
--- a/source/blender/python/intern/bpy_rna_gizmo.c
+++ b/source/blender/python/intern/bpy_rna_gizmo.c
@@ -63,7 +63,7 @@ static void py_rna_gizmo_handler_get_cb(const wmGizmo *UNUSED(gz),
                                         wmGizmoProperty *gz_prop,
                                         void *value_p)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
 
   struct BPyGizmoHandlerUserData *data = gz_prop->custom_func.user_data;
   PyObject *ret = PyObject_CallObject(data->fn_slots[BPY_GIZMO_FN_SLOT_GET], NULL);
@@ -110,7 +110,7 @@ static void py_rna_gizmo_handler_set_cb(const wmGizmo *UNUSED(gz),
                                         wmGizmoProperty *gz_prop,
                                         const void *value_p)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
 
   struct BPyGizmoHandlerUserData *data = gz_prop->custom_func.user_data;
 
@@ -159,7 +159,7 @@ static void py_rna_gizmo_handler_range_get_cb(const wmGizmo *UNUSED(gz),
 {
   struct BPyGizmoHandlerUserData *data = gz_prop->custom_func.user_data;
 
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
 
   PyObject *ret = PyObject_CallObject(data->fn_slots[BPY_GIZMO_FN_SLOT_RANGE_GET], NULL);
   if (ret == NULL) {
@@ -211,7 +211,7 @@ static void py_rna_gizmo_handler_free_cb(const wmGizmo *UNUSED(gz), wmGizmoPrope
 {
   struct BPyGizmoHandlerUserData *data = gz_prop->custom_func.user_data;
 
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
   for (int i = 0; i < BPY_GIZMO_FN_SLOT_LEN; i++) {
     Py_XDECREF(data->fn_slots[i]);
   }
@@ -234,7 +234,7 @@ PyDoc_STRVAR(
     "   :type range: callable\n");
 static PyObject *bpy_gizmo_target_set_handler(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
 {
-  PyGILState_STATE gilstate = PyGILState_Ensure();
+  const PyGILState_STATE gilstate = PyGILState_Ensure();
 
   struct {
     PyObject *self;
@@ -368,7 +368,7 @@ static PyObject *bpy_gizmo_target_get_value(PyObject *UNUSED(self), PyObject *ar
         return PyC_Tuple_PackArray_F32(value, array_len);
       }
 
-      float value = WM_gizmo_target_property_float_get(gz, gz_prop);
+      const float value = WM_gizmo_target_property_float_get(gz, gz_prop);
       return PyFloat_FromDouble(value);
 
       break;
diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c
index 308d2ef9618..ca38d7008f6 100644
--- a/source/blender/python/mathutils/mathutils.c
+++ b/source/blender/python/mathutils/mathutils.c
@@ -208,7 +208,7 @@ int mathutils_array_parse(
 
   if (size != -1) {
     if (flag & MU_ARRAY_ZERO) {
-      int size_left = array_max - size;
+      const int size_left = array_max - size;
       if (size_left) {
         memset(&array[size], 0, sizeof(float) * size_left);
       }
@@ -541,9 +541,9 @@ int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
 {
   /* solid, fast routine across all platforms
    * with constant time behavior */
-  int ai = *(int *)(&af);
-  int bi = *(int *)(&bf);
-  int test = SIGNMASK(ai ^ bi);
+  const int ai = *(int *)(&af);
+  const int bi = *(int *)(&bf);
+  const int test = SIGNMASK(ai ^ bi);
   int diff, v1, v2;
 
   assert((0 == test) || (0xFFFFFFFF == test));
diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c
index 6bffff467cd..8a7f782de3c 100644
--- a/source/blender/python/mathutils/mathutils_Color.c
+++ b/source/blender/python/mathutils/mathutils_Color.c
@@ -749,7 +749,7 @@ PyDoc_STRVAR(Color_channel_hsv_v_doc, "HSV Value component in [0, 1].\n\n:type:
 static PyObject *Color_channel_hsv_get(ColorObject *self, void *type)
 {
   float hsv[3];
-  int i = POINTER_AS_INT(type);
+  const int i = POINTER_AS_INT(type);
 
   if (BaseMath_ReadCallback(self) == -1) {
     return NULL;
@@ -763,7 +763,7 @@ static PyObject *Color_channel_hsv_get(ColorObject *self, void *type)
 static int Color_channel_hsv_set(ColorObject *self, PyObject *value, void *type)
 {
   float hsv[3];
-  int i = POINTER_AS_INT(type);
+  const int i = POINTER_AS_INT(type);
   float f = PyFloat_AsDouble(value);
 
   if (f == -1 && PyErr_Occurred()) {
diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c
index 236bb1de29d..0a524cbf24c 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.c
+++ b/source/blender/python/mathutils/mathutils_Matrix.c
@@ -809,7 +809,7 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
   else {
     /* arbitrary plane */
 
-    int vec_size = (matSize == 2 ? 2 : 3);
+    const int vec_size = (matSize == 2 ? 2 : 3);
     float tvec[4];
 
     if (mathutils_array_parse(tvec,
@@ -2156,7 +2156,8 @@ static PyObject *Matrix_str(MatrixObject *self)
   for (col = 0; col < self->num_col; col++) {
     maxsize[col] = 0;
     for (row = 0; row < self->num_row; row++) {
-      int size = BLI_snprintf(dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col));
+      const int size = BLI_snprintf(
+          dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col));
       maxsize[col] = max_ii(maxsize[col], size);
     }
   }
diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c
index 3ee6e766413..9bc8c0dffed 100644
--- a/source/blender/python/mathutils/mathutils_Vector.c
+++ b/source/blender/python/mathutils/mathutils_Vector.c
@@ -356,7 +356,7 @@ PyDoc_STRVAR(Vector_normalize_doc,
              "      however 4D Vectors w axis is left untouched.\n");
 static PyObject *Vector_normalize(VectorObject *self)
 {
-  int size = (self->size == 4 ? 3 : self->size);
+  const int size = (self->size == 4 ? 3 : self->size);
   if (BaseMath_ReadCallback_ForWrite(self) == -1) {
     return NULL;
   }
@@ -2027,7 +2027,7 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
 {
   VectorObject *vecA = NULL, *vecB = NULL;
   int result = 0;
-  double epsilon = 0.000001f;
+  const double epsilon = 0.000001f;
   double lenA, lenB;
 
   if (!VectorObject_Check(objectA) || !VectorObject_Check(objectB)) {
diff --git a/source/blender/python/mathutils/mathutils_bvhtree.c b/source/blender/python/mathutils/mathutils_bvhtree.c
index 0c53639c67d..1d477421e30 100644
--- a/source/blender/python/mathutils/mathutils_bvhtree.c
+++ b/source/blender/python/mathutils/mathutils_bvhtree.c
@@ -549,8 +549,7 @@ static bool py_bvhtree_overlap_cb(void *userdata, int index_a, int index_b, int
     }
   }
 
-  return (isect_tri_tri_v3(
-              UNPACK3(tri_a_co), UNPACK3(tri_b_co), ix_pair[0], ix_pair[1]) &&
+  return (isect_tri_tri_v3(UNPACK3(tri_a_co), UNPACK3(tri_b_co), ix_pair[0], ix_pair[1]) &&
           ((verts_shared == 0) || (len_squared_v3v3(ix_pair[0], ix_pair[1]) > data->epsilon)));
 }
 
@@ -590,7 +589,7 @@ static PyObject *py_bvhtree_overlap(PyBVHTree *self, PyBVHTree *other)
     /* pass */
   }
   else {
-    bool use_unique = (self->orig_index || other->orig_index);
+    const bool use_unique = (self->orig_index || other->orig_index);
     GSet *pair_test = use_unique ?
                           BLI_gset_new_ex(overlap_hash, overlap_cmp, __func__, overlap_len) :
                           NULL;
@@ -1038,7 +1037,7 @@ static Mesh *bvh_get_mesh(const char *funcname,
 {
   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
   /* we only need minimum mesh data for topology and vertex locations */
-  CustomData_MeshMasks data_masks = CD_MASK_BAREMESH;
+  const CustomData_MeshMasks data_masks = CD_MASK_BAREMESH;
   const bool use_render = DEG_get_mode(depsgraph) == DAG_EVAL_RENDER;
   *r_free_mesh = false;
 
@@ -1054,7 +1053,7 @@ static Mesh *bvh_get_mesh(const char *funcname,
       }
 
       *r_free_mesh = true;
-      return mesh_create_eval_final_render(depsgraph, scene, ob, &data_masks);
+      return mesh_create_eval_final(depsgraph, scene, ob, &data_masks);
     }
     if (ob_eval != NULL) {
       if (use_cage) {
diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c
index 37997e9f912..1a161924f96 100644
--- a/source/blender/python/mathutils/mathutils_geometry.c
+++ b/source/blender/python/mathutils/mathutils_geometry.c
@@ -315,7 +315,7 @@ static PyObject *M_Geometry_intersect_tri_tri_2d(PyObject *UNUSED(self), PyObjec
     }
   }
 
-  bool ret = isect_tri_tri_v2(UNPACK3(tri_pair[0]), UNPACK3(tri_pair[1]));
+  const bool ret = isect_tri_tri_v2(UNPACK3(tri_pair[0]), UNPACK3(tri_pair[1]));
   return PyBool_FromLong(ret);
 }
 
@@ -492,7 +492,7 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
   PyObject *py_line_a, *py_line_b, *py_plane_co, *py_plane_no;
   float line_a[3], line_b[3], plane_co[3], plane_no[3];
   float isect[3];
-  bool no_flip = false;
+  const bool no_flip = false;
 
   if (!PyArg_ParseTuple(args,
                         "OOOO|O&:intersect_line_plane",
@@ -1639,7 +1639,6 @@ static PyObject *M_Geometry_delaunay_2d_cdt(PyObject *UNUSED(self), PyObject *ar
   in.faces_start_table = in_faces_start_table;
   in.faces_len_table = in_faces_len_table;
   in.epsilon = epsilon;
-  in.skip_input_modify = false;
 
   res = BLI_delaunay_2d_cdt_calc(&in, output_type);
 
diff --git a/source/blender/python/mathutils/mathutils_kdtree.c b/source/blender/python/mathutils/mathutils_kdtree.c
index c3e66546dae..1de3c23838f 100644
--- a/source/blender/python/mathutils/mathutils_kdtree.c
+++ b/source/blender/python/mathutils/mathutils_kdtree.c
@@ -191,7 +191,7 @@ static int py_find_nearest_cb(void *user_data, int index, const float co[3], flo
 
   if (result) {
     bool use_node;
-    int ok = PyC_ParseBool(result, &use_node);
+    const int ok = PyC_ParseBool(result, &use_node);
     Py_DECREF(result);
     if (ok) {
       return (int)use_node;