Slic3r::PythonPluginBridge Class Reference

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

Public Member Functions
void	begin_plugin_capture (const std::string &plugin_key)
std::vector< CapturedCapability >	finalize_plugin_capture (const std::string &capture_key, const std::string &plugin_key, std::string &error)
void	cancel_plugin_capture (const std::string &plugin_key)
void	clear_pending_captures ()

Static Public Member Functions
static PythonPluginBridge &	instance ()

Private Member Functions
	PythonPluginBridge ()=default
	PythonPluginBridge (const PythonPluginBridge &)=delete
PythonPluginBridge &	operator= (const PythonPluginBridge &)=delete

Detailed Description

Constructor & Destructor Documentation

PythonPluginBridge() [1/2]

Slic3r::PythonPluginBridge::PythonPluginBridge ( )

privatedefault

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

Here is the caller graph for this function:

PythonPluginBridge() [2/2]

Slic3r::PythonPluginBridge::PythonPluginBridge ( const PythonPluginBridge & )

privatedelete

References PythonPluginBridge().

Here is the call graph for this function:

Member Function Documentation

begin_plugin_capture()

void Slic3r::PythonPluginBridge::begin_plugin_capture

(

const std::string &

plugin_key

)

{
    PythonGILState gil;
    if (!gil) {
        BOOST_LOG_TRIVIAL(warning) << "Cannot begin Python plugin capture while the interpreter is shutting down";
        return;
    }
    BOOST_LOG_TRIVIAL(info) << "Beginning Python plugin capture for key " << plugin_key;
    {
        std::lock_guard<std::mutex> lock(g_registry_mutex);
        // Start from a clean slot in case a previous failed load left pending Python classes
        // for this same entry path.
        g_pending_capabilities.erase(plugin_key);
        g_pending_package.erase(plugin_key);
        g_pending_permissions.erase(plugin_key);
    }
    // From now until finalize/cancel, @orca.plugin and register_capability() calls made by
    // Python code on this thread are attributed to this plugin.
    g_active_plugin_key = plugin_key;
}

Referenced by Slic3r::plugin_loader::load().

Here is the caller graph for this function:

cancel_plugin_capture()

void Slic3r::PythonPluginBridge::cancel_plugin_capture

(

const std::string &

plugin_key

)

{
    PythonGILState gil;
    BOOST_LOG_TRIVIAL(warning) << "Cancelling Python plugin capture for key " << plugin_key;
 
    if (!gil) {
        discard_pending_capture_without_python(plugin_key);
        if (g_active_plugin_key == plugin_key)
            g_active_plugin_key.clear();
        return;
    }
 
    {
        std::lock_guard<std::mutex> lock(g_registry_mutex);
        // Import or dependency setup failed before finalization. Drop anything the module
        // may already have registered under this key.
        g_pending_capabilities.erase(plugin_key);
        g_pending_package.erase(plugin_key);
        g_pending_permissions.erase(plugin_key);
    }
 
    if (g_active_plugin_key == plugin_key)
        g_active_plugin_key.clear();
}

Referenced by Slic3r::plugin_loader::load().

Here is the caller graph for this function:

clear_pending_captures()

void Slic3r::PythonPluginBridge::clear_pending_captures

(

)

{
    PythonGILState gil;
    if (!gil) {
        std::lock_guard<std::mutex> lock(g_registry_mutex);
        BOOST_LOG_TRIVIAL(info) << "Clearing " << g_pending_capabilities.size()
                                << " pending Python plugin capture(s) without Python interpreter";
        // py::object destruction would decref Python objects. If the interpreter is already
        // gone, release the wrappers instead and intentionally skip decref.
        for (auto& [plugin_key, plugins] : g_pending_capabilities) {
            (void) plugin_key;
            for (py::object& plugin : plugins)
                (void) plugin.release();
        }
        g_pending_capabilities.clear();
        for (auto& [plugin_key, pkg] : g_pending_package) {
            (void) plugin_key;
            (void) pkg.release();
        }
        g_pending_package.clear();
        g_pending_permissions.clear();
        g_active_plugin_key.clear();
        return;
    }
 
    std::lock_guard<std::mutex> lock(g_registry_mutex);
    BOOST_LOG_TRIVIAL(info) << "Clearing " << g_pending_capabilities.size() << " pending Python plugin capture(s)";
    g_pending_capabilities.clear();
    g_pending_package.clear();
    g_pending_permissions.clear();
    g_active_plugin_key.clear();
}

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

Here is the caller graph for this function:

finalize_plugin_capture()

std::vector< CapturedCapability > Slic3r::PythonPluginBridge::finalize_plugin_capture	(	const std::string &	capture_key,
		const std::string &	plugin_key,
		std::string &	error )

{
    PythonGILState gil;
    if (!gil) {
        error = "Python interpreter is shutting down";
        return {};
    }
    BOOST_LOG_TRIVIAL(info) << "Finalizing Python plugin capture for key " << capture_key;
 
    // Phase 1: run the package class's register_capabilities() while the active key is
    // still set. That method is expected to call orca.register_capability() once per
    // capability class, and register_capability() needs g_active_plugin_key to know which
    // pending bucket to append to.
    {
        auto clear_active_key = [&capture_key]() {
            if (g_active_plugin_key == capture_key)
                g_active_plugin_key.clear();
        };
        auto discard_pending_for_key = [&capture_key]() {
            std::lock_guard<std::mutex> lock(g_registry_mutex);
            g_pending_capabilities.erase(capture_key);
            g_pending_package.erase(capture_key);
            g_pending_permissions.erase(capture_key);
        };
 
        try {
            // The @orca.plugin decorator records the package class during module import.
            // Move it into a local py::object and remove it from the pending map so the
            // registry no longer owns it once finalization starts.
            py::object package_cls;
            {
                std::lock_guard<std::mutex> lock(g_registry_mutex);
                auto it = g_pending_package.find(capture_key);
                if (it != g_pending_package.end()) {
                    package_cls = it->second;
                    g_pending_package.erase(it);
                }
            }
            if (!package_cls) {
                error = "Plugin did not register a package class; decorate it with @orca.plugin";
                BOOST_LOG_TRIVIAL(error) << error << " for key " << plugin_key;
                discard_pending_for_key();
                clear_active_key();
                return {};
            }
 
            // The package instance is only a registration coordinator. It is not returned
            // to the rest of the plugin system; only the capability classes it registers
            // are kept.
            py::object package = package_cls();
            package.attr("register_capabilities")();
 
            // Permission declarations are collected while register_capabilities() runs so the
            // plugin can describe its needs without touching wx from the Python load worker. Ask
            // only after registration returns, before capability instances are materialized.
            PluginPermissions requested_permissions;
            {
                std::lock_guard<std::mutex> lock(g_registry_mutex);
                auto it = g_pending_permissions.find(capture_key);
                if (it != g_pending_permissions.end()) {
                    requested_permissions = std::move(it->second);
                    g_pending_permissions.erase(it);
                }
            }
            const bool has_permission_request =
                !requested_permissions.fs_read.empty() || !requested_permissions.fs_readwrite.empty() ||
                !requested_permissions.network_http.empty() || !requested_permissions.network_socket.empty() ||
                !requested_permissions.process.empty() || !requested_permissions.threading.empty();
            if (has_permission_request) {
                bool granted = false;
                {
                    py::gil_scoped_release release;
                    granted = PluginAuditManager::instance().request_permissions(plugin_key, requested_permissions);
                }
                if (!granted) {
                    error = _u8L("Plugin permission request denied");
                    BOOST_LOG_TRIVIAL(warning) << error << " for key " << plugin_key;
                    discard_pending_for_key();
                    clear_active_key();
                    return {};
                }
            }
        } catch (py::error_already_set& err) {
            log_python_exception_keep(err);
            error = err.what();
            BOOST_LOG_TRIVIAL(error) << "Plugin register_capabilities raised Python exception for key " << plugin_key
                                     << " error=" << error;
            discard_pending_for_key();
            clear_active_key();
            return {};
        } catch (const std::exception& ex) {
            error = ex.what();
            BOOST_LOG_TRIVIAL(error) << "Plugin register_capabilities raised exception for key " << plugin_key
                                     << " error=" << error;
            discard_pending_for_key();
            clear_active_key();
            return {};
        }
    }
 
    // Phase 2: move the capability classes that register_capabilities() appended into a
    // local vector. From this point the pending registry no longer owns these py::objects.
    std::vector<py::object> classes;
    {
        std::lock_guard<std::mutex> lock(g_registry_mutex);
        auto it = g_pending_capabilities.find(capture_key);
        if (it != g_pending_capabilities.end()) {
            classes = std::move(it->second);
            g_pending_capabilities.erase(it);
        }
    }
 
    // Registration is complete. Later register_capability() calls should fail instead of
    // accidentally attaching themselves to this plugin.
    if (g_active_plugin_key == capture_key)
        g_active_plugin_key.clear();
 
    BOOST_LOG_TRIVIAL(info) << "Collected " << classes.size() << " registered capability class(es) for key " << capture_key;
 
    std::vector<CapturedCapability> capabilities;
    capabilities.reserve(classes.size());
 
    // Phase 3: instantiate each registered capability class and convert it to the common
    // C++ interface used by the rest of OrcaSlicer.
    for (auto& cls : classes) {
        try {
            py::object instance = cls();
            if (!py::isinstance<PluginCapabilityInterface>(instance)) {
                error = "Registered capability must inherit from a PluginCapability base";
                BOOST_LOG_TRIVIAL(error) << "Python plugin capture failed type check for key " << capture_key
                                         << " error=" << error;
                return {};
            }
 
            auto capability_iface = instance.cast<std::shared_ptr<PluginCapabilityInterface>>();
            if (!capability_iface) {
                error = "Failed to cast Python capability to PluginCapabilityInterface";
                BOOST_LOG_TRIVIAL(error) << "Python plugin capture failed cast for key " << capture_key
                                         << " error=" << error;
                return {};
            }
 
            // This is a registered capability, not the transient orca.base package.
            // get_name() is required on capabilities and is cached for preset lookup.
            std::string name = capability_iface->get_name();
 
            // Capability names feed ';'-delimited config/preset serialization and drive
            // dispatch, so unlike display names they cannot be silently rewritten — a ';'
            // here is a hard error that rejects the whole plugin capture.
            if (name.find(';') != std::string::npos) {
                error = "Capability name must not contain ';': " + name;
                BOOST_LOG_TRIVIAL(error) << "Python plugin capture rejected capability for key " << capture_key
                                         << " error=" << error;
                return {};
            }
 
            auto handle        = std::make_shared<PluginInstanceHandle>();
            handle->keep_alive = instance;
            handle->plugin     = std::move(capability_iface);
 
            CapturedCapability captured;
            // Return a shared_ptr<PluginCapabilityInterface> while keeping PluginInstanceHandle
            // as the owner, so the Python instance stays alive as long as the C++ interface does.
            captured.instance = std::shared_ptr<PluginCapabilityInterface>(handle, handle->plugin.get());
            captured.name     = std::move(name);
            capabilities.emplace_back(std::move(captured));
        } catch (py::error_already_set& err) {
            // Direct Python call (cls() / get_name() above), not a trampoline override —
            // log the traceback here. GIL is held for the duration of finalize_plugin_capture.
            log_python_exception_keep(err);
            error = err.what();
            BOOST_LOG_TRIVIAL(error) << "Python plugin capture raised Python exception for key " << capture_key
                                     << " error=" << error;
            return {};
        } catch (const std::exception& ex) {
            error = ex.what();
            BOOST_LOG_TRIVIAL(error) << "Python plugin capture raised exception for key " << capture_key
                                     << " error=" << error;
            return {};
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "Instantiated " << capabilities.size() << " Python capability instance(s) for key " << plugin_key;
    return capabilities;
}

References _u8L, Slic3r::PluginPermissions::fs_read, Slic3r::PluginPermissions::fs_readwrite, Slic3r::CapturedCapability::instance, Slic3r::PluginAuditManager::instance(), instance(), Slic3r::log_python_exception_keep(), Slic3r::CapturedCapability::name, Slic3r::PluginPermissions::network_http, Slic3r::PluginPermissions::network_socket, Slic3r::PluginPermissions::process, and Slic3r::PluginPermissions::threading.

Referenced by Slic3r::plugin_loader::load().

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

PythonPluginBridge & Slic3r::PythonPluginBridge::instance ( )

static

{
    static PythonPluginBridge bridge;
    return bridge;
}

References PythonPluginBridge().

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

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

privatedelete

References PythonPluginBridge().

Here is the call graph for this function:

---

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

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