14#include <frameobject.h>
16#ifdef WITH_PYTHON_MODULE
17# include "pylifecycle.h"
92static int bpy_timer_count = 0;
94static double bpy_timer;
96static double bpy_timer_run;
98static double bpy_timer_run_tot;
121 *gilstate = PyGILState_Ensure();
128 if (bpy_timer_count == 0) {
131 bpy_timer_run = bpy_timer_run_tot = 0.0;
145 PyGILState_Release(*gilstate);
149 fprintf(stderr,
"ERROR: Python context internal state bug. this should not happen!\n");
175 const char *context_members[],
176 uint context_members_len)
178 PyGILState_STATE gilstate;
181 gilstate = PyGILState_Ensure();
185 if (*dict_p == dict_orig) {
186 *dict_p = PyDict_Copy(
static_cast<PyObject *
>(dict_orig));
189 PyObject *dict =
static_cast<PyObject *
>(*dict_p);
194 for (
uint i = 0; i < context_members_len; i++) {
195 PyObject *
key = PyUnicode_FromString(context_members[i]);
196 PyObject *item = _PyDict_Pop(dict,
key, Py_None);
202 PyGILState_Release(gilstate);
209 PyGILState_STATE gilstate;
213 gilstate = PyGILState_Ensure();
216 Py_DECREF((PyObject *)text->
compiled);
220 PyGILState_Release(gilstate);
230 PyObject *
mod = PyImport_ImportModuleLevel(
"bpy",
nullptr,
nullptr,
nullptr, 0);
254#ifdef WITH_AUDASPACE_PY
261static PyObject *CCL_initPython()
293#ifdef WITH_AUDASPACE_PY
297 {
"_cycles", CCL_initPython},
307#ifndef WITH_PYTHON_MODULE
319 if (
UNLIKELY(PyStatus_Exception(status))) {
320 fputs(
"Internal error initializing Python!\n", stderr);
322 Py_ExitStatusException(status);
329#ifndef WITH_PYTHON_MODULE
330 BLI_assert_msg(Py_IsInitialized() == 0,
"Python has already been initialized");
334 PyPreConfig preconfig;
341 "Initializing %s support for the systems Python environment such as 'PYTHONPATH' and "
342 "the user-site directory.",
346 PyPreConfig_InitPythonConfig(&preconfig);
352 PyPreConfig_InitIsolatedConfig(&preconfig);
368 preconfig.utf8_mode =
true;
373 status = Py_PreInitialize(&preconfig);
384 bool has_python_executable =
false;
387 PyConfig_InitPythonConfig(&config);
392 PyConfig_InitIsolatedConfig(&config);
397 config.install_signal_handlers = 1;
402 config.pathconfig_warnings = 0;
414 config.parse_argv = 0;
415 status = PyConfig_SetBytesArgv(&config, argc, (
char *
const *)argv);
425 status = PyConfig_SetBytesString(&config, &config.program_name, program_path);
434 program_path,
sizeof(program_path), PY_MAJOR_VERSION, PY_MINOR_VERSION))
436 status = PyConfig_SetBytesString(&config, &config.executable, program_path);
438 has_python_executable =
true;
443 "Unable to find the Python binary, "
444 "the multiprocessing module may not be functional!\n");
452 if (py_path_bundle.has_value()) {
458 if (strchr(py_path_bundle->c_str(),
':')) {
460 "Warning! Blender application is located in a path containing ':' or '/' chars\n"
461 "This may make Python import function fail\n");
465 status = PyConfig_SetBytesString(&config, &config.home, py_path_bundle->c_str());
468# ifdef PYTHON_SSL_CERT_FILE
470 const char *ssl_cert_file_env =
"SSL_CERT_FILE";
471 if (
BLI_getenv(ssl_cert_file_env) ==
nullptr) {
472 const char *ssl_cert_file_suffix = PYTHON_SSL_CERT_FILE;
475 ssl_cert_file,
sizeof(ssl_cert_file), py_path_bundle->c_str(), ssl_cert_file_suffix);
482# if defined(__APPLE__) || defined(_WIN32)
484 "Bundled Python not found and is expected on this platform "
485 "(the 'install' target may have not been built)\n");
491 status = Py_InitializeFromConfig(&config);
492 PyConfig_Clear(&config);
496 if (!has_python_executable) {
497 PySys_SetObject(
"executable", Py_None);
504 Py_DECREF(PyImport_ImportModule(
"threading"));
522#ifdef WITH_PYTHON_MODULE
525 struct _inittab *inittab_item;
526 PyObject *sys_modules = PyImport_GetModuleDict();
529 PyObject *
mod = inittab_item->initfunc();
531 PyDict_SetItemString(sys_modules, inittab_item->name,
mod);
550#ifndef WITH_PYTHON_MODULE
555 PyEval_ReleaseThread(PyGILState_GetThisThreadState());
559#ifdef WITH_PYTHON_MODULE
561 const char *imports[] = {
"atexit",
"addon_utils",
nullptr};
568#ifndef WITH_PYTHON_MODULE
569 BLI_assert_msg(Py_IsInitialized() != 0,
"Python must be initialized");
573 PyGILState_STATE gilstate = PyGILState_Ensure();
596#ifndef WITH_PYTHON_MODULE
600 if (do_python_exit) {
605 PyGILState_Release(gilstate);
606 (void)do_python_exit;
614 printf(
"tot exec: %d, ", bpy_timer_count);
615 printf(
"tot run: %.4fsec, ", bpy_timer_run_tot);
616 if (bpy_timer_count > 0) {
617 printf(
"average run: %.6fsec, ", (bpy_timer_run_tot / bpy_timer_count));
620 if (bpy_timer > 0.0) {
621 printf(
"tot usage %.4f%%", (bpy_timer_run_tot / bpy_timer) * 100.0);
630 BLI_assert_msg(Py_IsInitialized() != 0,
"Python must be initialized");
634 G.autoexec_fail[0] =
'\0';
654 fputs(
"\n# Python backtrace\n", fp);
660 PyFrameObject *
frame = PyEval_GetFrame();
661 if (
frame ==
nullptr) {
665 PyCodeObject *code = PyFrame_GetCode(
frame);
666 const int line = PyFrame_GetLineNumber(
frame);
667 const char *filepath = PyUnicode_AsUTF8(code->co_filename);
668 const char *funcname = PyUnicode_AsUTF8(code->co_name);
669 fprintf(fp,
" File \"%s\", line %d in %s\n", filepath, line, funcname);
675 const PyGILState_STATE gilstate = PyGILState_Ensure();
676 Py_DECREF((PyObject *)pyob_ptr);
677 PyGILState_Release(gilstate);
682 const PyGILState_STATE gilstate = PyGILState_Ensure();
683 const bool do_invalidate = (Py_REFCNT((PyObject *)pyob_ptr) > 1);
684 Py_DECREF((PyObject *)pyob_ptr);
688 PyGILState_Release(gilstate);
693 PyGILState_STATE gilstate;
698 if (bmain ==
nullptr) {
717 if (module_conf->script) {
720 RPT_(
"Freestyle style module '%s'"),
721 module_conf->script->id.name + 2);
737 printf(
"scripts disabled for \"%s\", skipping '%s'\n",
758 PyGILState_STATE gilstate;
761 gilstate = PyGILState_Ensure();
770 item = PyDict_GetItemString(pyctx, member);
772 if (item ==
nullptr) {
775 else if (item == Py_None) {
786 else if (PySequence_Check(item)) {
787 PyObject *seq_fast = PySequence_Fast(item,
"bpy_context_get sequence conversion");
788 if (seq_fast ==
nullptr) {
793 const int len = PySequence_Fast_GET_SIZE(seq_fast);
794 PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
797 for (i = 0; i <
len; i++) {
798 PyObject *list_item = seq_fast_items[i];
807 "'%s' list item not a valid type in sequence type '%s'",
809 Py_TYPE(item)->tp_name);
831 PyGILState_Release(gilstate);
837#ifdef WITH_PYTHON_MODULE
840static void bpy_module_free(
void *
mod);
843extern int main_python_enter(
int argc,
const char **argv);
844extern void main_python_exit();
846static struct PyModuleDef bpy_proxy_def = {
847 PyModuleDef_HEAD_INIT,
865static void bpy_module_delay_init(PyObject *bpy_proxy)
871 PyObject *filepath_obj = PyModule_GetFilenameObject(bpy_proxy);
874 const char *filepath_rel = PyUnicode_AsUTF8(filepath_obj);
875 char filepath_abs[1024];
877 STRNCPY(filepath_abs, filepath_rel);
879 Py_DECREF(filepath_obj);
881 argv[0] = filepath_abs;
884 main_python_enter(argc, argv);
887 PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(
bpy_package_py));
894static bool bpy_module_ensure_compatible_version()
900 const uint version_runtime = Py_Version;
902 uint version_compile_major = PY_VERSION_HEX >> 24;
903 uint version_compile_minor = ((PY_VERSION_HEX & 0x00ff0000) >> 16);
904 uint version_runtime_major = version_runtime >> 24;
905 uint version_runtime_minor = ((version_runtime & 0x00ff0000) >> 16);
906 if ((version_compile_major != version_runtime_major) ||
907 (version_compile_minor != version_runtime_minor))
909 PyErr_Format(PyExc_ImportError,
910 "The version of \"bpy\" was compiled with: "
911 "(%u.%u) is incompatible with: (%u.%u) used by the interpreter!",
912 version_compile_major,
913 version_compile_minor,
914 version_runtime_major,
915 version_runtime_minor);
921static void dealloc_obj_dealloc(PyObject *
self);
923static PyTypeObject dealloc_obj_Type;
926static void dealloc_obj_dealloc(PyObject *
self)
928 bpy_module_delay_init(((dealloc_obj *)
self)->
mod);
932 dealloc_obj_Type.tp_free(
self);
935PyMODINIT_FUNC PyInit_bpy();
937PyMODINIT_FUNC PyInit_bpy()
939 if (!bpy_module_ensure_compatible_version()) {
943 PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def);
963 dealloc_obj_Type.tp_name =
"dealloc_obj";
964 dealloc_obj_Type.tp_basicsize =
sizeof(dealloc_obj);
965 dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
966 dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
968 if (PyType_Ready(&dealloc_obj_Type) < 0) {
972 dob = (dealloc_obj *)dealloc_obj_Type.tp_alloc(&dealloc_obj_Type, 0);
973 dob->mod = bpy_proxy;
974 PyModule_AddObject(bpy_proxy,
"__file__", (PyObject *)dob);
979static void bpy_module_free(
void * )
989 const char *kwlist[] = {
990 "False",
"None",
"True",
"and",
"as",
"assert",
"async",
"await",
"break",
991 "class",
"continue",
"def",
"del",
"elif",
"else",
"except",
"finally",
"for",
992 "from",
"global",
"if",
"import",
"in",
"is",
"lambda",
"nonlocal",
"not",
993 "or",
"pass",
"raise",
"return",
"try",
"while",
"with",
"yield",
nullptr,
996 for (
int i = 0; kwlist[i]; i++) {
PyObject * AUD_initPython(void)
const char * BKE_appdir_program_path() ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
bool BKE_appdir_program_python_search(char *program_filepath, size_t program_filepath_maxncpy, int version_major, int version_minor) ATTR_NONNULL(1)
std::optional< std::string > BKE_appdir_folder_id(int folder_id, const char *subfolder) ATTR_WARN_UNUSED_RESULT
void CTX_wm_operator_poll_msg_clear(bContext *C)
Main * CTX_data_main(const bContext *C)
@ CTX_DATA_TYPE_COLLECTION
void CTX_data_list_add_ptr(bContextDataResult *result, const PointerRNA *ptr)
void CTX_data_pointer_set_ptr(bContextDataResult *result, const PointerRNA *ptr)
void * CTX_py_dict_get(const bContext *C)
void CTX_data_type_set(bContextDataResult *result, short type)
@ G_FLAG_SCRIPT_AUTOEXEC_FAIL_QUIET
@ G_FLAG_SCRIPT_AUTOEXEC_FAIL
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
bool text_check_identifier_nodigit(char ch)
bool text_check_identifier(char ch)
#define BLI_assert_msg(a, msg)
#define LISTBASE_FOREACH(type, var, list)
void BLI_setenv(const char *env, const char *val) ATTR_NONNULL(1)
#define BLI_path_join(...)
const char * BLI_getenv(const char *env) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
bool BLI_path_abs_from_cwd(char *path, size_t path_maxncpy) ATTR_NONNULL(1)
#define SNPRINTF(dst, format,...)
char * STRNCPY(char(&dst)[N], const char *src)
int BLI_thread_is_main(void)
Platform independent time functions.
double BLI_time_now_seconds(void)
void BPY_app_handlers_reset(bool do_all)
struct CLG_LogRef * BPY_LOG_RNA
struct CLG_LogRef * BPY_LOG_CONTEXT
bool bool BPY_run_text(bContext *C, Text *text, ReportList *reports, bool do_jump) ATTR_NONNULL(1
bool BPY_run_string_eval(bContext *C, const char *imports[], const char *expr)
void * CCL_python_module_init(void)
#define CLG_LOGREF_DECLARE_GLOBAL(var, id)
#define CLOG_INFO(clg_ref, level,...)
PyMODINIT_FUNC BPyInit_bl_math()
PyObject * BPyInit_bmesh()
PyObject * BPyInit_bmesh_geometry()
PyObject * BPyInit_bmesh_types()
PyObject * BPyInit_bmesh_utils()
PyObject * bpy_package_py
void BPy_init_modules(bContext *C)
void BPY_atexit_unregister()
void BPY_atexit_register()
struct CLG_LogRef * BPY_LOG_INTERFACE
void BPY_app_translations_end()
int text_check_identifier_nodigit_unicode(const uint ch)
bool BPY_string_is_keyword(const char *str)
void BPY_python_use_system_env()
void BPY_context_dict_clear_members_array(void **dict_p, void *dict_orig, const char *context_members[], uint context_members_len)
int text_check_identifier_unicode(const uint ch)
int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *result)
void BPY_modules_update()
bContext * BPY_context_get()
void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
void BPY_context_set(bContext *C)
static void pystatus_exit_on_error(const PyStatus &status)
void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
void BPY_python_backtrace(FILE *fp)
static void bpy_context_end(bContext *C)
void BPY_python_reset(bContext *C)
static bool py_use_system_env
void BPY_context_update(bContext *C)
void BPY_python_end(const bool do_python_exit)
static _inittab bpy_internal_modules[]
bool BPY_python_use_system_env_get()
void BPY_text_free_code(Text *text)
void bpy_context_clear(bContext *, const PyGILState_STATE *gilstate)
void BPY_modules_load_user(bContext *C)
void BPY_python_start(bContext *C, int argc, const char **argv)
void BPY_DECREF(void *pyob_ptr)
void bpy_intern_string_exit()
void bpy_intern_string_init()
PyObject * BPyInit__bpy_path()
void BPY_rna_props_clear_all()
void pyrna_invalidate(BPy_DummyPointerRNA *self)
PyObject * BPY_rna_module()
PyObject * BPY_rna_types()
void BPY_update_rna_module()
BPy_StructRNA * bpy_context_module
#define BPy_StructRNA_Check(v)
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
PyObject * BPyInit_idprop()
PyObject * BPyInit_imbuf()
PyObject * Manta_initPython(void)
PyMODINIT_FUNC PyInit_mathutils()
PyMODINIT_FUNC PyInit_mathutils_geometry()
PyMODINIT_FUNC PyInit_mathutils_kdtree()
PyMODINIT_FUNC PyInit_mathutils_noise()
bool PyC_IsInterpreterActive()
PyObject * BPyInit_hydra()
header-only compatibility defines.
#define PyThreadState_GetUnchecked
PyObject_HEAD std::optional< PointerRNA > ptr