Slic3r::PythonInterpreter Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PythonInterpreter.hpp>

Collaboration diagram for Slic3r::PythonInterpreter:

Public Member Functions
bool	initialize ()
bool	is_initialized () const
PythonRuntimeLease	acquire_runtime_lease ()
const std::string &	last_error () const
void	shutdown ()
bool	add_plugin_sys_path (const std::string &path, std::string &error)
PyObject *	load_module_from_file (const std::string &file_path, std::string &error, std::vector< std::string > *plugin_paths=nullptr, std::vector< std::string > *plugin_modules=nullptr)
PyObject *	load_module_from_whl (const std::string &whl_path, const std::string &pkg_name, std::string &error, std::vector< std::string > *plugin_paths=nullptr, std::vector< std::string > *plugin_modules=nullptr)
PyObject *	load_module_from_directory (const std::string &dir_path, const std::string &pkg_name, std::string &error, std::vector< std::string > *plugin_paths=nullptr, std::vector< std::string > *plugin_modules=nullptr)
void	unload_module (PyObject *module, const std::string &module_name, const std::vector< std::string > &plugin_paths, const std::vector< std::string > &plugin_modules)
	~PythonInterpreter ()

Static Public Member Functions
static PythonInterpreter &	instance ()
static std::string	shared_packages_dir ()
static std::string	bundled_python_executable ()
static std::string	bundled_uv_path ()
static std::string	python_abi_tag ()
static int	join_non_daemon_threads (std::chrono::milliseconds timeout)

Private Member Functions
	PythonInterpreter ()=default
	PythonInterpreter (const PythonInterpreter &)=delete
PythonInterpreter &	operator= (const PythonInterpreter &)=delete
bool	add_plugin_sys_path_locked (const std::string &path, std::string &error)
void	remove_plugin_sys_paths_locked (const std::vector< std::string > &paths)
void	record_plugin_modules_locked (const std::string &module_name, const std::vector< std::string > &plugin_paths, std::vector< std::string > *plugin_modules)
void	remove_plugin_modules_locked (const std::vector< std::string > &plugin_modules)
void	remove_module_tree_locked (const std::string &module_name)
void	abandon ()

Private Attributes
std::atomic< bool >	m_initialized {false}
std::shared_timed_mutex	m_runtime_mutex
PyThreadState *	m_main_thread_state = nullptr
std::unique_ptr< pybind11::scoped_interpreter >	m_interpreter
std::string	m_last_error
std::unordered_map< std::string, std::size_t >	m_plugin_path_users
std::unordered_map< std::string, bool >	m_plugin_path_owned
std::unordered_map< std::string, std::size_t >	m_plugin_module_users
std::unordered_map< std::string, bool >	m_plugin_module_owned

Friends
class	PythonRuntimeLease

Detailed Description

Constructor & Destructor Documentation

~PythonInterpreter()

Slic3r::PythonInterpreter::~PythonInterpreter

(

)

{ shutdown(); }

References shutdown().

Here is the call graph for this function:

PythonInterpreter() [1/2]

Slic3r::PythonInterpreter::PythonInterpreter ( )

privatedefault

Referenced by PythonInterpreter(), instance(), and operator=().

Here is the caller graph for this function:

PythonInterpreter() [2/2]

Slic3r::PythonInterpreter::PythonInterpreter ( const PythonInterpreter & )

privatedelete

References PythonInterpreter().

Here is the call graph for this function:

Member Function Documentation

abandon()

void Slic3r::PythonInterpreter::abandon ( )

private

{
    // New leases fail from here on. Releasing the scoped_interpreter without destroying it skips
    // Py_Finalize, here and in the static destructor; the process exit ends the interpreter.
    m_initialized.store(false, std::memory_order_release);
    static_cast<void>(m_interpreter.release());
}

References m_initialized, and m_interpreter.

Referenced by shutdown().

Here is the caller graph for this function:

acquire_runtime_lease()

PythonRuntimeLease Slic3r::PythonInterpreter::acquire_runtime_lease ( )

inline

{
    return PythonRuntimeLease(*this);
}

References PythonRuntimeLease.

Referenced by Slic3r::PythonGILState::PythonGILState(), and Slic3r::ScriptAsyncRuntime::Impl::run_invocation().

Here is the call graph for this function:

Here is the caller graph for this function:

add_plugin_sys_path()

bool Slic3r::PythonInterpreter::add_plugin_sys_path	(	const std::string &	path,
		std::string &	error )

{
    if (!m_initialized.load(std::memory_order_acquire)) {
        error = "Python interpreter not initialized";
        return false;
    }
 
    PythonGILState gil;
    if (!gil) {
        error = "Python interpreter is shutting down";
        return false;
    }
 
    return add_plugin_sys_path_locked(path, error);
}

References add_plugin_sys_path_locked(), and m_initialized.

Referenced by Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::add_wheel_dependencies_to_sys_path().

Here is the call graph for this function:

Here is the caller graph for this function:

add_plugin_sys_path_locked()

bool Slic3r::PythonInterpreter::add_plugin_sys_path_locked ( const std::string & path, std::string & error )

private

{
    bool inserted = false;
    if (!add_sys_path_entry(boost::filesystem::path(path), error, &inserted))
        return false;
 
    auto users = m_plugin_path_users.find(path);
    if (users == m_plugin_path_users.end()) {
        m_plugin_path_owned[path] = inserted;
        m_plugin_path_users.emplace(path, 1);
    } else {
        ++users->second;
    }
 
    return true;
}

References m_plugin_path_owned, and m_plugin_path_users.

Referenced by add_plugin_sys_path(), load_module_from_directory(), and load_module_from_file().

Here is the caller graph for this function:

bundled_python_executable()

std::string Slic3r::PythonInterpreter::bundled_python_executable ( )

static

{
    const boost::filesystem::path python_home = find_bundled_python_home();
    if (python_home.empty())
        return {};
 
    const boost::filesystem::path executable = find_python_executable(python_home);
    return executable.empty() ? std::string{} : executable.string();
}

Referenced by Slic3r::plugin_loader::install_packages(), and Slic3r::GUI::TerminalDialog::resolve_and_run().

Here is the caller graph for this function:

bundled_uv_path()

std::string Slic3r::PythonInterpreter::bundled_uv_path ( )

static

{
    namespace fs = boost::filesystem;
 
    const fs::path configured_uv = ORCA_BUNDLED_UV_EXECUTABLE;
    if (!configured_uv.empty() && fs::exists(configured_uv) && fs::is_regular_file(configured_uv))
        return configured_uv.string();
 
    // <binary dir>/tools/uv covers the macOS bundle (Contents/MacOS/tools/uv)
    // and build-tree runs; <resources>/tools/uv covers the install() and
    // AppImage layouts.
    const std::string uv_exe               = executable_name("uv");
    const std::vector<fs::path> candidates = {
        fs::path(resources_dir()) / "tools" / "uv" / uv_exe,
        boost::dll::program_location().parent_path() / "tools" / "uv" / uv_exe,
    };
 
    for (const fs::path& candidate : candidates) {
        if (fs::exists(candidate) && fs::is_regular_file(candidate))
            return candidate.string();
    }
 
    return {};
}

References Slic3r::resources_dir().

Referenced by initialize(), Slic3r::plugin_loader::install_packages(), and Slic3r::GUI::TerminalDialog::resolve_and_run().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

bool Slic3r::PythonInterpreter::initialize

(

)

{
    std::unique_lock<std::shared_timed_mutex> runtime_lock(m_runtime_mutex);
    if (m_initialized.load(std::memory_order_acquire)) {
        return true;
    }
 
    m_last_error.clear();
    m_plugin_path_users.clear();
    m_plugin_path_owned.clear();
    m_plugin_module_users.clear();
    m_plugin_module_owned.clear();
 
    try {
        // Set Python home to the bundled Python installation
        // This is critical for finding the standard library (encodings module, etc.)
 
        namespace fs = boost::filesystem;
        const std::string python_home = find_bundled_python_home().string();
 
        if (python_home.empty()) {
            m_last_error = "Could not locate bundled Python installation";
            BOOST_LOG_TRIVIAL(error) << "Could not locate bundled Python installation";
            BOOST_LOG_TRIVIAL(error) << "Configured bundled Python root: " << ORCA_BUNDLED_PYTHON_ROOT;
#ifdef _WIN32
            BOOST_LOG_TRIVIAL(error) << "Searched next to executable: "
                                     << (boost::dll::program_location().parent_path() / "python").string();
#endif
            BOOST_LOG_TRIVIAL(error) << "Searched in resources_dir: " << resources_dir();
#ifndef _WIN32
            BOOST_LOG_TRIVIAL(error) << "Searched in data_dir: " << data_dir();
#endif
            BOOST_LOG_TRIVIAL(error) << "CMAKE_PREFIX_PATH: "
                                     << (std::getenv("CMAKE_PREFIX_PATH") ? std::getenv("CMAKE_PREFIX_PATH") : "not set");
            return false;
        }
 
        BOOST_LOG_TRIVIAL(info) << "Found bundled Python home: " << python_home;
 
// Verify Python standard library directory exists
#ifdef _WIN32
        fs::path python_lib = fs::path(python_home) / "Lib";
#else
        fs::path python_lib = fs::path(python_home) / "lib" / PYTHON_STDLIB_DIR;
#endif
        if (!fs::exists(python_lib)) {
            m_last_error = "Python standard library directory not found at: " + python_lib.string();
            BOOST_LOG_TRIVIAL(error) << "Python standard library directory not found at: " << python_lib.string();
            BOOST_LOG_TRIVIAL(error) << "Please build Python dependencies or check installation";
            return false;
        }
 
        BOOST_LOG_TRIVIAL(info) << "Python standard library found at: " << python_lib.string();
 
#ifdef _WIN32
        fs::path python_dll = fs::exists(fs::path(python_home) / PYTHON_DLL) ? fs::path(python_home) / PYTHON_DLL :
                                                                               fs::path(python_home) / PYTHON_DEBUG_DLL;
        if (!fs::exists(python_dll)) {
            m_last_error = "Python DLL not found in: " + python_home;
            BOOST_LOG_TRIVIAL(error) << "Python DLL not found in: " << python_home;
            return false;
        }
        BOOST_LOG_TRIVIAL(info) << "Python DLL found at: " << python_dll.string();
        if (!fs::exists(fs::path(python_home) / "DLLs")) {
            BOOST_LOG_TRIVIAL(warning) << "Python DLLs directory not found at: " << (fs::path(python_home) / "DLLs").string();
        }
#endif
 
        // Log the exact paths being used for debugging
        BOOST_LOG_TRIVIAL(info) << "Setting Python home to: " << python_home;
        BOOST_LOG_TRIVIAL(info) << "Python 3.12 stdlib path: " << python_lib.string();
 
        // Verify encodings module exists
        fs::path encodings_path = python_lib / "encodings";
        if (fs::exists(encodings_path)) {
            BOOST_LOG_TRIVIAL(info) << "Encodings module found at: " << encodings_path.string();
        } else {
            BOOST_LOG_TRIVIAL(warning) << "Encodings module NOT found at: " << encodings_path.string();
        }
 
        BOOST_LOG_TRIVIAL(info) << "Using Python 3.12 PyConfig initialization API";
 
        // Set Python home - this is the prefix where Python libraries are located
        PyConfig config;
        PyConfig_InitPythonConfig(&config);
        // Do not let the host process's PYTHONPATH or user site-packages override the bundled
        // runtime used by plugins.
        config.use_environment    = 0;
        config.user_site_directory = 0;
 
        BOOST_LOG_TRIVIAL(debug) << "Calling PyConfig_SetBytesString with home=" << python_home;
        PyStatus status = PyConfig_SetBytesString(&config, &config.home, python_home.c_str());
        if (PyStatus_Exception(status)) {
            m_last_error = status.err_msg ? status.err_msg : "Failed to set Python home";
            BOOST_LOG_TRIVIAL(error) << "Failed to set Python home to: " << python_home << ": " << m_last_error;
            PyConfig_Clear(&config);
            return false;
        }
        BOOST_LOG_TRIVIAL(debug) << "Python home set successfully";
 
        // Set program name
        status = PyConfig_SetBytesString(&config, &config.program_name, "OrcaSlicer");
        if (PyStatus_Exception(status)) {
            m_last_error = status.err_msg ? status.err_msg : "Failed to set program name";
            BOOST_LOG_TRIVIAL(error) << "Failed to set program name: " << m_last_error;
            PyConfig_Clear(&config);
            return false;
        }
        BOOST_LOG_TRIVIAL(debug) << "Program name set successfully";
 
        // Keep bytecode out of the Python home. The shipped .pyc files are stale against their
        // sources, so a writable install would rewrite them inside the app (breaking a signed
        // macOS bundle's seal) and a read-only one would recompile them on every launch.
        const std::string pycache_prefix = data_dir() + "/python/pycache";
#ifdef _WIN32
        status = PyConfig_SetString(&config, &config.pycache_prefix, boost::nowide::widen(pycache_prefix).c_str());
#else
        status = PyConfig_SetBytesString(&config, &config.pycache_prefix, pycache_prefix.c_str());
#endif
        if (PyStatus_Exception(status))
            BOOST_LOG_TRIVIAL(warning) << "Failed to set the Python bytecode cache to " << pycache_prefix << ": "
                                       << (status.err_msg ? status.err_msg : "unknown error");
 
        // Use pybind11's scoped_interpreter which properly initializes
        // pybind11 internals for multi-threaded use — raw Py_InitializeFromConfig
        // does not set up thread state tracking that pybind11 requires.
        BOOST_LOG_TRIVIAL(debug) << "Creating py::scoped_interpreter with PyConfig...";
        try {
            m_interpreter = std::make_unique<pybind11::scoped_interpreter>(&config);
        } catch (const std::exception& ex) {
            m_last_error = std::string("Python initialization failed: ") + ex.what();
            BOOST_LOG_TRIVIAL(error) << m_last_error;
            PyConfig_Clear(&config);
            return false;
        }
        // PyConfig is cleared by pybind11's initialize_interpreter() internally.
        BOOST_LOG_TRIVIAL(debug) << "py::scoped_interpreter initialized successfully";
 
        if (!Py_IsInitialized()) {
            m_last_error = "Python interpreter not initialized";
            BOOST_LOG_TRIVIAL(error) << "Python interpreter not initialized";
            return false;
        }
 
        // Log Python paths for debugging
        PyObject* sys = PyImport_ImportModule("sys");
        if (sys) {
            PyObject* path = PyObject_GetAttrString(sys, "path");
            if (path) {
                PyObject* path_str = PyObject_Str(path);
                if (path_str) {
                    const char* path_cstr = PyUnicode_AsUTF8(path_str);
                    if (path_cstr) {
                        BOOST_LOG_TRIVIAL(debug) << "Python sys.path: " << path_cstr;
                    }
                    Py_DECREF(path_str);
                }
                Py_DECREF(path);
            }
            Py_DECREF(sys);
        }
 
        BOOST_LOG_TRIVIAL(info) << "Python " << Py_GetVersion() << " initialized successfully";
 
        const fs::path shared_packages = shared_packages_dir();
        boost::system::error_code ec;
        fs::create_directories(shared_packages, ec);
        if (ec) {
            BOOST_LOG_TRIVIAL(warning) << "Failed to create Python shared package directory: " << shared_packages.string() << ": "
                                       << ec.message();
        } else {
            std::string path_error;
            if (add_sys_path_entry(shared_packages, path_error))
                BOOST_LOG_TRIVIAL(info) << "Added Python shared package directory to sys.path: " << shared_packages.string();
            else
                BOOST_LOG_TRIVIAL(warning) << path_error;
        }
 
        const std::string uv_path = bundled_uv_path();
        if (!uv_path.empty())
            BOOST_LOG_TRIVIAL(info) << "Bundled uv executable found at: " << uv_path;
        else
            BOOST_LOG_TRIVIAL(info) << "Bundled uv executable not found";
 
        PluginAuditManager::instance().install_hook();
 
        // Persist Python stderr (plugin tracebacks, including uncaught
        // background-thread exceptions) to <data_dir>/log/python_*.log.
        install_python_stderr_redirect();
 
        // Attribute plugin-spawned Python threads to the plugin/capability that created them.
        // Must run while the GIL is still held here, after the audit hook is in place and
        // before the GIL is released below.
        install_python_thread_audit_shim();
 
        // Release the GIL so other threads can acquire it via PyGILState_Ensure.
        // Without this, calls from background threads will block trying to acquire the GIL.
        m_main_thread_state = PyEval_SaveThread();
        m_initialized.store(true, std::memory_order_release);
        BOOST_LOG_TRIVIAL(debug) << "Main thread released Python GIL after initialization";
        return true;
 
    } catch (const std::exception& ex) {
        m_last_error = std::string("Exception initializing Python: ") + ex.what();
        BOOST_LOG_TRIVIAL(error) << "Exception initializing Python: " << ex.what();
        return false;
    }
}

References bundled_uv_path(), Slic3r::data_dir(), Slic3r::PluginAuditManager::install_hook(), Slic3r::install_python_thread_audit_shim(), Slic3r::PluginAuditManager::instance(), m_initialized, m_interpreter, m_last_error, m_main_thread_state, m_plugin_module_owned, m_plugin_module_users, m_plugin_path_owned, m_plugin_path_users, m_runtime_mutex, Slic3r::resources_dir(), and shared_packages_dir().

Referenced by Slic3r::PluginManager::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

PythonInterpreter & Slic3r::PythonInterpreter::instance ( )

static

{
    static PythonInterpreter inst;
    return inst;
}

References PythonInterpreter().

Referenced by Slic3r::PythonGILState::PythonGILState(), Slic3r::GUI::GUI_App::~GUI_App(), Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::add_wheel_dependencies_to_sys_path(), Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::import_plugin_module(), Slic3r::PluginManager::initialize(), Slic3r::PluginManager::instance(), Slic3r::plugin_loader::load(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::Plugin::release_module(), Slic3r::ScriptAsyncRuntime::Impl::run_invocation(), Slic3r::ScriptAsyncRuntime::start(), and Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::teardown_capabilities().

Here is the call graph for this function:

Here is the caller graph for this function:

is_initialized()

bool Slic3r::PythonInterpreter::is_initialized ( ) const

inline

{ return m_initialized.load(std::memory_order_acquire); }

References m_initialized.

Referenced by Slic3r::PluginManager::initialize(), and Slic3r::plugin_loader::load().

Here is the caller graph for this function:

join_non_daemon_threads()

int Slic3r::PythonInterpreter::join_non_daemon_threads ( std::chrono::milliseconds timeout )

static

{
    try {
        const pybind11::module_ threading   = pybind11::module_::import("threading");
        const pybind11::object  main_thread = threading.attr("main_thread")();
        const auto              deadline    = std::chrono::steady_clock::now() + timeout;
        const auto              seconds_left = [deadline] {
            return std::chrono::duration<double>(
                       std::max(deadline - std::chrono::steady_clock::now(), std::chrono::steady_clock::duration::zero()))
                .count();
        };
 
        // An idle concurrent.futures worker only ends once the hooks registered with
        // threading._register_atexit() tell it to, which Py_Finalize does before it joins the
        // threads. They run first here, on a daemon thread: a hook joins its workers without a
        // timeout, so one stuck in a task would block the hook, and Py_Finalize, for good.
        pybind11::object hooks;
        if (pybind11::hasattr(threading, "_threading_atexits")) {
            hooks = threading.attr("Thread")(pybind11::arg("target") = pybind11::cpp_function([threading] {
                                                 const pybind11::list calls = threading.attr("_threading_atexits");
                                                 for (pybind11::ssize_t i = calls.size(); i-- > 0;)
                                                     calls[i]();
                                             }),
                                             pybind11::arg("name") = "orca-threading-atexit", pybind11::arg("daemon") = true);
            hooks.attr("start")();
            hooks.attr("join")(seconds_left());
        }
 
        // Enumerated again after each pass: a thread being joined may start another one.
        for (;;) {
            int seen    = 0;
            int running = 0;
            for (const pybind11::handle thread : threading.attr("enumerate")()) {
                // Threads Python did not start (C++ threads that entered Python) are dummy threads,
                // which are daemon and cannot be joined.
                if (thread.is(main_thread) || thread.attr("daemon").cast<bool>())
                    continue;
                ++seen;
                thread.attr("join")(seconds_left());
                if (thread.attr("is_alive")().cast<bool>())
                    ++running;
            }
            if (seen == 0 || std::chrono::steady_clock::now() >= deadline) {
                // A hook still running would be run again, and waited for, by Py_Finalize.
                if (hooks && hooks.attr("is_alive")().cast<bool>())
                    running = std::max(running, 1);
                return running;
            }
        }
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(warning) << "Could not wait for Python threads: " << ex.what();
        return 0;
    }
}

Referenced by shutdown().

Here is the caller graph for this function:

last_error()

const std::string & Slic3r::PythonInterpreter::last_error ( ) const

inline

{ return m_last_error; }

References m_last_error.

Referenced by Slic3r::PluginManager::initialize(), and Slic3r::plugin_loader::load().

Here is the caller graph for this function:

load_module_from_directory()

PyObject * Slic3r::PythonInterpreter::load_module_from_directory	(	const std::string &	dir_path,
		const std::string &	pkg_name,
		std::string &	error,
		std::vector< std::string > *	plugin_paths = nullptr,
		std::vector< std::string > *	plugin_modules = nullptr )

{
    if (!m_initialized.load(std::memory_order_acquire)) {
        error = "Python interpreter not initialized";
        return nullptr;
    }
 
    namespace fs = boost::filesystem;
    fs::path dir(dir_path);
 
    if (!fs::exists(dir) || !fs::is_directory(dir)) {
        error = "Directory does not exist: " + dir_path;
        return nullptr;
    }
 
    PythonGILState gil;
    if (!gil) {
        error = "Python interpreter is shutting down";
        return nullptr;
    }
 
    const std::string directory = dir.string();
    if (!add_plugin_sys_path_locked(directory, error))
        return nullptr;
    if (plugin_paths)
        plugin_paths->push_back(directory);
 
    remove_module_tree_locked(pkg_name);
 
    PyObject* module = PyImport_ImportModule(pkg_name.c_str());
    record_plugin_modules_locked(pkg_name, plugin_paths ? *plugin_paths : std::vector<std::string>{}, plugin_modules);
    if (!module) {
        PyObject *ptype, *pvalue, *ptraceback;
        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
        error = "Failed to import module: " + format_python_error(ptype, pvalue, ptraceback);
        Py_XDECREF(ptype);
        Py_XDECREF(pvalue);
        Py_XDECREF(ptraceback);
        return nullptr;
    }
 
    return module;
}

References add_plugin_sys_path_locked(), m_initialized, Slic3r::module(), record_plugin_modules_locked(), and remove_module_tree_locked().

Referenced by Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::import_plugin_module(), and load_module_from_whl().

Here is the call graph for this function:

Here is the caller graph for this function:

load_module_from_file()

PyObject * Slic3r::PythonInterpreter::load_module_from_file	(	const std::string &	file_path,
		std::string &	error,
		std::vector< std::string > *	plugin_paths = nullptr,
		std::vector< std::string > *	plugin_modules = nullptr )

{
    if (!m_initialized.load(std::memory_order_acquire)) {
        error = "Python interpreter not initialized";
        return nullptr;
    }
 
    namespace fs = boost::filesystem;
    fs::path path(file_path);
 
    if (!fs::exists(path)) {
        error = "File does not exist: " + file_path;
        return nullptr;
    }
 
    PythonGILState gil;
    if (!gil) {
        error = "Python interpreter is shutting down";
        return nullptr;
    }
 
    // Add the directory to sys.path
    fs::path dir_path       = path.parent_path();
    std::string module_name = path.stem().string();
 
    const std::string dir = dir_path.string();
    if (!add_plugin_sys_path_locked(dir, error))
        return nullptr;
    if (plugin_paths)
        plugin_paths->push_back(dir);
 
    // Ensure module is re-imported fresh by removing any cached instance.
    remove_module_tree_locked(module_name);
 
    // Import the module
    PyObject* module = PyImport_ImportModule(module_name.c_str());
    record_plugin_modules_locked(module_name, plugin_paths ? *plugin_paths : std::vector<std::string>{}, plugin_modules);
    if (!module) {
        PyObject *ptype, *pvalue, *ptraceback;
        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
        error = "Failed to import module: " + format_python_error(ptype, pvalue, ptraceback);
        Py_XDECREF(ptype);
        Py_XDECREF(pvalue);
        Py_XDECREF(ptraceback);
        return nullptr;
    }
 
    return module;
}

References add_plugin_sys_path_locked(), m_initialized, Slic3r::module(), record_plugin_modules_locked(), and remove_module_tree_locked().

Referenced by Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::import_plugin_module().

Here is the call graph for this function:

Here is the caller graph for this function:

load_module_from_whl()

PyObject * Slic3r::PythonInterpreter::load_module_from_whl	(	const std::string &	whl_path,
		const std::string &	pkg_name,
		std::string &	error,
		std::vector< std::string > *	plugin_paths = nullptr,
		std::vector< std::string > *	plugin_modules = nullptr )

{
    if (!m_initialized.load(std::memory_order_acquire)) {
        error = "Python interpreter not initialized";
        return nullptr;
    }
 
    namespace fs = boost::filesystem;
 
    fs::path whl_path(file_path);
 
    if (!fs::exists(whl_path)) {
        error = "File does not exist: " + file_path;
        return nullptr;
    }
 
    fs::path extract_dir = whl_path.parent_path() / "__whl_extracted__" / pkg_name;
 
    if (!fs::exists(extract_dir)) {
        if (!extract_zip_to_directory(whl_path, extract_dir, error))
            return nullptr;
    }
 
    return load_module_from_directory(extract_dir.string(), pkg_name, error, plugin_paths, plugin_modules);
}

References Slic3r::extract_zip_to_directory(), load_module_from_directory(), and m_initialized.

Referenced by Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::import_plugin_module().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

PythonInterpreter & Slic3r::PythonInterpreter::operator= ( const PythonInterpreter & )

privatedelete

References PythonInterpreter().

Here is the call graph for this function:

python_abi_tag()

std::string Slic3r::PythonInterpreter::python_abi_tag ( )

static

{
    return std::string("cp") + std::to_string(PY_MAJOR_VERSION) + std::to_string(PY_MINOR_VERSION);
}

Referenced by Slic3r::read_wheel_plugin_metadata(), and shared_packages_dir().

Here is the caller graph for this function:

record_plugin_modules_locked()

void Slic3r::PythonInterpreter::record_plugin_modules_locked ( const std::string & module_name, const std::vector< std::string > & plugin_paths, std::vector< std::string > * plugin_modules )

private

{
    if (!plugin_modules)
        return;
 
    PyObject* modules = PyImport_GetModuleDict();
    if (!modules)
        return;
 
    PyObjectPtr names(PyDict_Keys(modules));
    if (!names) {
        PyErr_Clear();
        return;
    }
 
    const std::string prefix = module_name + ".";
    const auto        path_matches = [](const std::string& file, const std::string& root) {
        namespace fs = boost::filesystem;
 
        boost::system::error_code ec;
        fs::path                  file_path = fs::weakly_canonical(fs::path(file), ec);
        if (ec) {
            ec.clear();
            file_path = fs::absolute(fs::path(file), ec);
        }
        if (ec)
            return false;
 
        ec.clear();
        fs::path root_path = fs::weakly_canonical(fs::path(root), ec);
        if (ec) {
            ec.clear();
            root_path = fs::absolute(fs::path(root), ec);
        }
        if (ec)
            return false;
 
        const std::string file_string = file_path.generic_string();
        std::string       root_string = root_path.generic_string();
        if (root_string.empty())
            return false;
        if (root_string.back() != '/')
            root_string.push_back('/');
        return file_string.compare(0, root_string.size(), root_string) == 0;
    };
 
    const Py_ssize_t count = PyList_Size(names.get());
    for (Py_ssize_t index = 0; index < count; ++index) {
        PyObject* name_obj = PyList_GetItem(names.get(), index); // borrowed reference
        if (!name_obj || !PyUnicode_Check(name_obj))
            continue;
 
        const char* name_utf8 = PyUnicode_AsUTF8(name_obj);
        if (!name_utf8) {
            PyErr_Clear();
            continue;
        }
 
        const std::string name(name_utf8);
        const bool        is_plugin_namespace = name == module_name || name.compare(0, prefix.size(), prefix) == 0;
        bool              is_plugin_path_module = false;
        if (!is_plugin_namespace) {
            PyObject* module = PyDict_GetItem(modules, name_obj); // borrowed reference
            if (!module)
                continue;
 
            PyObjectPtr file(PyObject_GetAttrString(module, "__file__"));
            if (file && PyUnicode_Check(file.get())) {
                const char* file_utf8 = PyUnicode_AsUTF8(file.get());
                if (file_utf8) {
                    for (const std::string& path : plugin_paths) {
                        if (path_matches(file_utf8, path)) {
                            is_plugin_path_module = true;
                            break;
                        }
                    }
                } else {
                    PyErr_Clear();
                }
            } else {
                PyErr_Clear();
            }
 
            if (!is_plugin_path_module) {
                PyObjectPtr package_path(PyObject_GetAttrString(module, "__path__"));
                if (package_path) {
                    const Py_ssize_t path_count = PySequence_Size(package_path.get());
                    if (path_count < 0) {
                        PyErr_Clear();
                    } else {
                        for (Py_ssize_t path_index = 0; path_index < path_count && !is_plugin_path_module; ++path_index) {
                            PyObjectPtr path_entry(PySequence_GetItem(package_path.get(), path_index));
                            if (!path_entry) {
                                PyErr_Clear();
                                continue;
                            }
                            if (!PyUnicode_Check(path_entry.get()))
                                continue;
                            const char* path_utf8 = PyUnicode_AsUTF8(path_entry.get());
                            if (!path_utf8) {
                                PyErr_Clear();
                                continue;
                            }
                            for (const std::string& path : plugin_paths) {
                                if (path_matches(path_utf8, path)) {
                                    is_plugin_path_module = true;
                                    break;
                                }
                            }
                        }
                    }
                } else {
                    PyErr_Clear();
                }
            }
        }
 
        if (!is_plugin_namespace && !is_plugin_path_module)
            continue;
 
        auto users = m_plugin_module_users.find(name);
        if (users == m_plugin_module_users.end()) {
            m_plugin_module_owned[name] = true;
            m_plugin_module_users.emplace(name, 1);
        } else {
            ++users->second;
        }
        plugin_modules->push_back(name);
    }
}

References count, Slic3r::PyObjectPtr::get(), m_plugin_module_owned, m_plugin_module_users, and Slic3r::module().

Referenced by load_module_from_directory(), and load_module_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_module_tree_locked()

void Slic3r::PythonInterpreter::remove_module_tree_locked ( const std::string & module_name )

private

{
    if (module_name.empty())
        return;
 
    PyObject* modules = PyImport_GetModuleDict();
    if (!modules)
        return;
 
    PyObjectPtr names(PyDict_Keys(modules));
    if (!names) {
        PyErr_Clear();
        return;
    }
 
    const std::string prefix = module_name + ".";
    const Py_ssize_t count  = PyList_Size(names.get());
    for (Py_ssize_t index = 0; index < count; ++index) {
        PyObject* name_obj = PyList_GetItem(names.get(), index); // borrowed reference
        if (!name_obj || !PyUnicode_Check(name_obj))
            continue;
 
        const char* name_utf8 = PyUnicode_AsUTF8(name_obj);
        if (!name_utf8) {
            PyErr_Clear();
            continue;
        }
 
        const std::string name(name_utf8);
        if (name != module_name && name.compare(0, prefix.size(), prefix) != 0)
            continue;
 
        if (PyDict_DelItem(modules, name_obj) != 0)
            PyErr_Clear();
    }
}

References count, and Slic3r::PyObjectPtr::get().

Referenced by load_module_from_directory(), load_module_from_file(), and unload_module().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_plugin_modules_locked()

void Slic3r::PythonInterpreter::remove_plugin_modules_locked ( const std::vector< std::string > & plugin_modules )

private

{
    PyObject* modules = PyImport_GetModuleDict();
    if (!modules)
        return;
 
    for (const std::string& name : plugin_modules) {
        auto users = m_plugin_module_users.find(name);
        if (users == m_plugin_module_users.end())
            continue;
 
        if (--users->second != 0)
            continue;
 
        const bool owned = m_plugin_module_owned[name];
        m_plugin_module_users.erase(users);
        m_plugin_module_owned.erase(name);
        if (owned && PyDict_DelItemString(modules, name.c_str()) != 0)
            PyErr_Clear();
    }
}

References m_plugin_module_owned, and m_plugin_module_users.

Referenced by unload_module().

Here is the caller graph for this function:

remove_plugin_sys_paths_locked()

void Slic3r::PythonInterpreter::remove_plugin_sys_paths_locked ( const std::vector< std::string > & paths )

private

{
    PyObject* sys_path = PySys_GetObject("path");
    if (!sys_path || !PyList_Check(sys_path)) {
        PyErr_Clear();
        return;
    }
 
    for (const std::string& path : paths) {
        auto users = m_plugin_path_users.find(path);
        if (users == m_plugin_path_users.end())
            continue;
 
        if (--users->second != 0)
            continue;
 
        const bool owned = m_plugin_path_owned[path];
        m_plugin_path_users.erase(users);
        m_plugin_path_owned.erase(path);
        if (!owned)
            continue;
 
        PyObjectPtr py_path(PyUnicode_DecodeFSDefault(path.c_str()));
        if (!py_path) {
            PyErr_Clear();
            continue;
        }
 
        for (Py_ssize_t index = PyList_Size(sys_path) - 1; index >= 0; --index) {
            PyObject* entry = PyList_GetItem(sys_path, index); // borrowed reference
            int         equal = entry ? PyObject_RichCompareBool(entry, py_path.get(), Py_EQ) : 0;
            if (equal == 1 && PySequence_DelItem(sys_path, index) != 0)
                PyErr_Clear();
            else if (equal < 0)
                PyErr_Clear();
        }
    }
}

References Slic3r::PyObjectPtr::get(), m_plugin_path_owned, and m_plugin_path_users.

Referenced by unload_module().

Here is the call graph for this function:

Here is the caller graph for this function:

shared_packages_dir()

std::string Slic3r::PythonInterpreter::shared_packages_dir ( )

static

{
    return (boost::filesystem::path(data_dir()) / "python" / "packages" / PythonInterpreter::python_abi_tag()).string();
}

References Slic3r::data_dir(), and python_abi_tag().

Referenced by initialize(), and Slic3r::plugin_loader::install_packages().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

void Slic3r::PythonInterpreter::shutdown

(

)

{
    // Checked before waiting for the lock too, so a second call after abandon() returns at once.
    if (!m_initialized.load(std::memory_order_acquire))
        return;
 
    // A plugin call that never returns keeps its runtime lease, and Py_Finalize joins every
    // non-daemon thread, so either would keep a closing app alive. Both are waited for briefly.
    constexpr auto wait = std::chrono::seconds(3);
 
    std::unique_lock<std::shared_timed_mutex> runtime_lock(m_runtime_mutex, std::defer_lock);
    if (!runtime_lock.try_lock_for(wait)) {
        // The GIL is not taken back here: the stuck call may be holding it, and nothing on this
        // thread runs Python after this point.
        BOOST_LOG_TRIVIAL(warning) << "Python interpreter left unfinalized: a plugin call is still running";
        abandon();
        return;
    }
    if (!m_initialized.load(std::memory_order_acquire))
        return;
 
    BOOST_LOG_TRIVIAL(info) << "Python interpreter shutdown enter";
 
    // Reacquire the GIL using the saved thread state before finalizing.
    if (m_main_thread_state) {
        BOOST_LOG_TRIVIAL(debug) << "Restoring Python main thread state before shutdown";
        PyEval_RestoreThread(m_main_thread_state);
        m_main_thread_state = nullptr;
    }
 
    // Before the stdio tee is torn down, so tracebacks from threads still ending reach the log.
    if (const int running = join_non_daemon_threads(wait); running > 0) {
        // The GIL stays with this thread, so anything released during process exit still holds it.
        BOOST_LOG_TRIVIAL(warning) << "Python interpreter left unfinalized: " << running << " non-daemon thread(s) still running";
        abandon();
        return;
    }
 
    log_and_restore_python_stdio();
 
    BOOST_LOG_TRIVIAL(info) << "Finalizing Python interpreter";
    m_interpreter.reset();
    BOOST_LOG_TRIVIAL(info) << "Python interpreter finalized";
 
    m_plugin_path_users.clear();
    m_plugin_path_owned.clear();
    m_plugin_module_users.clear();
    m_plugin_module_owned.clear();
    m_initialized.store(false, std::memory_order_release);
}

References abandon(), join_non_daemon_threads(), m_initialized, m_interpreter, m_main_thread_state, m_plugin_module_owned, m_plugin_module_users, m_plugin_path_owned, m_plugin_path_users, and m_runtime_mutex.

Referenced by Slic3r::GUI::GUI_App::~GUI_App(), ~PythonInterpreter(), and Slic3r::GUI::GUI_App::on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

unload_module()

void Slic3r::PythonInterpreter::unload_module	(	PyObject *	module,
		const std::string &	module_name,
		const std::vector< std::string > &	plugin_paths,
		const std::vector< std::string > &	plugin_modules )

{
    if (!module && plugin_paths.empty() && plugin_modules.empty())
        return;
 
    if (!m_initialized.load(std::memory_order_acquire))
        return;
 
    PythonGILState gil;
    if (!gil)
        return;
 
    remove_plugin_modules_locked(plugin_modules);
    if (plugin_modules.empty())
        remove_module_tree_locked(module_name);
    remove_plugin_sys_paths_locked(plugin_paths);
    Py_XDECREF(module);
}

References m_initialized, Slic3r::module(), remove_module_tree_locked(), remove_plugin_modules_locked(), and remove_plugin_sys_paths_locked().

Referenced by Slic3r::Plugin::release_module().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

PythonRuntimeLease

friend class PythonRuntimeLease

friend

References PythonRuntimeLease.

Referenced by acquire_runtime_lease(), and PythonRuntimeLease.

Member Data Documentation

m_initialized

std::atomic<bool> Slic3r::PythonInterpreter::m_initialized {false}

private

{false};

Referenced by Slic3r::PythonRuntimeLease::PythonRuntimeLease(), abandon(), add_plugin_sys_path(), initialize(), is_initialized(), load_module_from_directory(), load_module_from_file(), load_module_from_whl(), shutdown(), and unload_module().

m_interpreter

std::unique_ptr<pybind11::scoped_interpreter> Slic3r::PythonInterpreter::m_interpreter

private

Referenced by abandon(), initialize(), and shutdown().

m_last_error

std::string Slic3r::PythonInterpreter::m_last_error

private

Referenced by initialize(), and last_error().

m_main_thread_state

PyThreadState* Slic3r::PythonInterpreter::m_main_thread_state = nullptr

private

Referenced by initialize(), and shutdown().

m_plugin_module_owned

std::unordered_map<std::string, bool> Slic3r::PythonInterpreter::m_plugin_module_owned

private

Referenced by initialize(), record_plugin_modules_locked(), remove_plugin_modules_locked(), and shutdown().

m_plugin_module_users

std::unordered_map<std::string, std::size_t> Slic3r::PythonInterpreter::m_plugin_module_users

private

Referenced by initialize(), record_plugin_modules_locked(), remove_plugin_modules_locked(), and shutdown().

m_plugin_path_owned

std::unordered_map<std::string, bool> Slic3r::PythonInterpreter::m_plugin_path_owned

private

Referenced by add_plugin_sys_path_locked(), initialize(), remove_plugin_sys_paths_locked(), and shutdown().

m_plugin_path_users

std::unordered_map<std::string, std::size_t> Slic3r::PythonInterpreter::m_plugin_path_users

private

Referenced by add_plugin_sys_path_locked(), initialize(), remove_plugin_sys_paths_locked(), and shutdown().

m_runtime_mutex

std::shared_timed_mutex Slic3r::PythonInterpreter::m_runtime_mutex

mutableprivate

Referenced by Slic3r::PythonRuntimeLease::PythonRuntimeLease(), initialize(), and shutdown().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PythonInterpreter.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PythonInterpreter.cpp