PythonPluginManager Class Reference

#include <PythonPluginManager.h>

Inheritance diagram for PythonPluginManager:

Public Slots
void	unloadAllModules ()

Public Member Functions
PythonPluginsModel *	model ()
PythonPlugin *	plugin (int index)
const QList< PythonPlugin > &	plugins () const
	PythonPluginManager ()
void	scanPlugins ()
void	setPluginEnabled (PythonPlugin &plugin, bool enabled)
void	tryLoadEnabledPlugins ()

Private Member Functions
void	loadModule (PythonPlugin &plugin)
void	unloadModule (PythonPlugin &plugin)

Static Private Member Functions
static QPair< QString, PyKrita::version_checker >	parseDependency (const QString &)
static void	verifyDependenciesSetStatus (PythonPlugin &)
static bool	verifyModuleExists (PythonPlugin &)

Private Attributes
PythonPluginsModel	m_model
QList< PythonPlugin >	m_plugins

Detailed Description

The Python plugin manager handles discovery, loading and unloading of Python plugins. To get a reference to the manager, use PyKrita::pluginManager().

Definition at line 108 of file PythonPluginManager.h.

Constructor & Destructor Documentation

PythonPluginManager()

PythonPluginManager::PythonPluginManager

(

)

Definition at line 93 of file PythonPluginManager.cpp.

        : QObject(0)
        , m_model(0, this)
{}

Member Function Documentation

loadModule()

void PythonPluginManager::loadModule ( PythonPlugin & plugin )

private

Definition at line 345 of file PythonPluginManager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(plugin.isEnabled());
 
    // We can't know if a plugin is still broken until we try to load it
    plugin.m_broken = false;
    plugin.m_errorReason.clear();
 
    QString module_name = plugin.moduleName();
    KisUsageLogger::writeSysInfo("\t" + module_name);
    dbgScript << "Loading module: " << module_name;
 
    PyKrita::Python py = PyKrita::Python();
 
    // Get 'plugins' key from 'pykrita' module dictionary.
    // Every entry has a module name as a key and 2 elements tuple as a value
    PyObject* plugins = py.itemString("plugins");
    KIS_SAFE_ASSERT_RECOVER_RETURN(plugins);
 
    PyObject* module = py.moduleImport(PQ(module_name));
    if (module) {
        // Move just loaded module to the dict
        const int ins_result = PyDict_SetItemString(plugins, PQ(module_name), module);
        KIS_SAFE_ASSERT_RECOVER_NOOP(ins_result == 0);
        Py_DECREF(module);
        // Handle failure in release mode.
        if (ins_result == 0) {
            // Initialize the module from Python's side
            PyObject* const args = Py_BuildValue("(s)", PQ(module_name));
            PyObject* result = py.functionCall("_pluginLoaded", PyKrita::Python::PYKRITA_ENGINE, args);
            Py_DECREF(args);
            if (result) {
                dbgScript << "\t" << "success!";
                plugin.m_loaded = true;
                return;
            }
        }
        plugin.m_errorReason = i18nc("@info:tooltip", "Internal engine failure");
    } else {
        plugin.m_errorReason = i18nc(
                                   "@info:tooltip"
                                   , "Module not loaded:<br/><code>%1</code>"
                                   , py.lastTraceback().replace("\n", "<br/>")
                               );
    }
    plugin.m_broken = true;
    warnScript << "Error loading plugin" << module_name;
}

References dbgScript, PyKrita::Python::functionCall(), PythonPlugin::isEnabled(), PyKrita::Python::itemString(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, PyKrita::Python::lastTraceback(), PythonPlugin::m_broken, PythonPlugin::m_errorReason, PythonPlugin::m_loaded, PythonPlugin::moduleName(), plugin(), plugins(), PQ, PyKrita::Python::PYKRITA_ENGINE, warnScript, and KisUsageLogger::writeSysInfo().

model()

PythonPluginsModel * PythonPluginManager::model

(

)

Definition at line 111 of file PythonPluginManager.cpp.

{
    return &m_model;
}

References m_model.

parseDependency()

QPair< QString, PyKrita::version_checker > PythonPluginManager::parseDependency ( const QString & d )

staticprivate

Definition at line 160 of file PythonPluginManager.cpp.

{
    // Check if dependency has package info attached
    const int pnfo = d.indexOf('(');
    if (pnfo != -1) {
        QString dependency = d.mid(0, pnfo);
        QString version_str = d.mid(pnfo + 1, d.size() - pnfo - 2).trimmed();
        dbgScript << "Desired version spec [" << dependency << "]:" << version_str;
        PyKrita::version_checker checker = PyKrita::version_checker::fromString(version_str);
        if (!(checker.isValid() && d.endsWith(')'))) {
            dbgScript << "Invalid version spec " << d;
            QString reason = i18nc(
                                 "@info:tooltip"
                                 , "<p>Specified version has invalid format for dependency <application>%1</application>: "
                                 "<icode>%2</icode>. Skipped</p>"
                                 , dependency
                                 , version_str
                             );
            return qMakePair(reason, PyKrita::version_checker());
        }
        return qMakePair(dependency, checker);
    }
    return qMakePair(d, PyKrita::version_checker(PyKrita::version_checker::undefined));
}

References dbgScript, PyKrita::version_checker::fromString(), PyKrita::version_checker::isValid(), and PyKrita::version_checker::undefined.

plugin()

PythonPlugin * PythonPluginManager::plugin

(

int

index

)

Definition at line 103 of file PythonPluginManager.cpp.

                                                    {
    if (index >= 0 && index < m_plugins.count()) {
        return &m_plugins[index];
    }
 
    return nullptr;
}

References m_plugins.

plugins()

const QList< PythonPlugin > & PythonPluginManager::plugins

(

)

const

Definition at line 98 of file PythonPluginManager.cpp.

{
    return m_plugins;
}

References m_plugins.

scanPlugins()

void PythonPluginManager::scanPlugins

(

)

Definition at line 285 of file PythonPluginManager.cpp.

{
    m_plugins.clear();
 
    KConfigGroup pluginSettings(KSharedConfig::openConfig(), "python");
 
    QStringList desktopFiles = KoResourcePaths::findAllAssets("data", "pykrita/*desktop");
 
    Q_FOREACH(const QString &desktopFile, desktopFiles) {
 
        KDesktopFile df(desktopFile);
        df.setLocale(currentLocale());
        const KConfigGroup dg = df.desktopGroup();
        if (dg.readEntry("ServiceTypes") == "Krita/PythonPlugin") {
            PythonPlugin plugin;
            plugin.m_comment = df.readComment();
            plugin.m_name = df.readName();
            plugin.m_moduleName = dg.readEntry("X-KDE-Library");
            plugin.m_desktopFilePath = QFileInfo(desktopFile).filePath();
 
            QString manual = dg.readEntry("X-Krita-Manual");
            if (!manual.isEmpty()) {
                plugin.m_manualPath = QFileInfo(desktopFile).path() + "/" + plugin.m_moduleName + "/" + manual;
            }
            if (!plugin.isValid()) {
                dbgScript << plugin.name() << "is not usable";
                continue;
            }
 
            if (!verifyModuleExists(plugin)) {
                dbgScript << "Cannot load" << plugin.name() << ": broken"
                          << plugin.isBroken()
                          << "because:" << plugin.errorReason();
                continue;
            }
 
            verifyDependenciesSetStatus(plugin);
 
            plugin.m_enabled = pluginSettings.readEntry(QString("enable_") + plugin.moduleName(), false);
 
            m_plugins.append(plugin);
        }
    }
}

References currentLocale(), dbgScript, PythonPlugin::errorReason(), KoResourcePaths::findAllAssets(), PythonPlugin::isBroken(), PythonPlugin::isValid(), PythonPlugin::m_comment, PythonPlugin::m_desktopFilePath, PythonPlugin::m_enabled, PythonPlugin::m_manualPath, PythonPlugin::m_moduleName, PythonPlugin::m_name, m_plugins, PythonPlugin::moduleName(), PythonPlugin::name(), plugin(), verifyDependenciesSetStatus(), and verifyModuleExists().

setPluginEnabled()

void PythonPluginManager::setPluginEnabled	(	PythonPlugin &	plugin,
		bool	enabled )

Definition at line 423 of file PythonPluginManager.cpp.

{
    bool wasEnabled = plugin.isEnabled();
 
    if (wasEnabled && !enabled && plugin.m_loaded) {
        unloadModule(plugin);
    }
 
    plugin.m_enabled = enabled;
    KConfigGroup pluginSettings(KSharedConfig::openConfig(), "python");
    pluginSettings.writeEntry(QString("enable_") + plugin.moduleName(), enabled);
 
    if (!wasEnabled && enabled) {
        loadModule(plugin);
    }
}

References PythonPlugin::isEnabled(), loadModule(), PythonPlugin::m_enabled, PythonPlugin::m_loaded, PythonPlugin::moduleName(), plugin(), and unloadModule().

tryLoadEnabledPlugins()

void PythonPluginManager::tryLoadEnabledPlugins

(

)

Definition at line 330 of file PythonPluginManager.cpp.

{
    KisUsageLogger::writeSysInfo("Loaded Python Plugins");
    for (PythonPlugin &plugin : m_plugins) {
        dbgScript << "Trying to load plugin" << plugin.moduleName()
                  << ". Enabled:" << plugin.isEnabled()
                  << ". Broken: " << plugin.isBroken();
 
        if (plugin.m_enabled && !plugin.isBroken()) {
            loadModule(plugin);
        }
    }
    KisUsageLogger::writeSysInfo("\n");
}

References dbgScript, PythonPlugin::isBroken(), PythonPlugin::isEnabled(), loadModule(), PythonPlugin::m_enabled, m_plugins, PythonPlugin::moduleName(), plugin(), and KisUsageLogger::writeSysInfo().

unloadAllModules

void PythonPluginManager::unloadAllModules ( )

slot

Definition at line 116 of file PythonPluginManager.cpp.

{
    Q_FOREACH(PythonPlugin plugin, m_plugins) {
        if (plugin.m_loaded) {
            unloadModule(plugin);
        }
    }
}

References PythonPlugin::m_loaded, m_plugins, plugin(), and unloadModule().

unloadModule()

void PythonPluginManager::unloadModule ( PythonPlugin & plugin )

private

Definition at line 394 of file PythonPluginManager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(plugin.m_loaded);
    KIS_SAFE_ASSERT_RECOVER_RETURN(!plugin.isBroken());
 
    dbgScript << "Unloading module: " << plugin.moduleName();
 
    PyKrita::Python py = PyKrita::Python();
 
    // Get 'plugins' key from 'pykrita' module dictionary
    PyObject* plugins = py.itemString("plugins");
    KIS_SAFE_ASSERT_RECOVER_RETURN(plugins);
 
    PyObject* const args = Py_BuildValue("(s)", PQ(plugin.moduleName()));
    py.functionCall("_pluginUnloading", PyKrita::Python::PYKRITA_ENGINE, args);
    Py_DECREF(args);
 
    // This will just decrement a reference count for module instance
    PyDict_DelItemString(plugins, PQ(plugin.moduleName()));
 
    // Remove the module also from 'sys.modules' dict to really unload it,
    // so if reloaded all @init actions will work again!
    PyObject* sys_modules = py.itemString("modules", "sys");
    KIS_SAFE_ASSERT_RECOVER_RETURN(sys_modules);
    PyDict_DelItemString(sys_modules, PQ(plugin.moduleName()));
 
    plugin.m_loaded = false;
}

References dbgScript, PyKrita::Python::functionCall(), PythonPlugin::isBroken(), PyKrita::Python::itemString(), KIS_SAFE_ASSERT_RECOVER_RETURN, PythonPlugin::m_loaded, PythonPlugin::moduleName(), plugin(), plugins(), PQ, and PyKrita::Python::PYKRITA_ENGINE.

verifyDependenciesSetStatus()

void PythonPluginManager::verifyDependenciesSetStatus ( PythonPlugin & plugin )

staticprivate

Collect dependencies and check them. To do it just try to import a module... when unload it ;)

X-Python-Dependencies property of .desktop file has the following format: python-module(version-info), where python-module a python module name to be imported, version-spec is a version triplet delimited by dots, possible w/ leading compare operator: =, <, >, <=, >=

Definition at line 195 of file PythonPluginManager.cpp.

{
    QStringList dependencies = plugin.property("X-Python-Dependencies").toStringList();
 
    PyKrita::Python py = PyKrita::Python();
    QString reason = i18nc("@info:tooltip", "<title>Dependency check</title>");
    Q_FOREACH(const QString & d, dependencies) {
        QPair<QString, PyKrita::version_checker> info_pair = parseDependency(d);
        PyKrita::version_checker& checker = info_pair.second;
        if (!checker.isValid()) {
            plugin.m_broken = true;
            reason += info_pair.first;
            continue;
        }
 
        dbgScript << "Try to import dependency module/package:" << d;
 
        // Try to import a module
        const QString& dependency = info_pair.first;
        PyObject* module = py.moduleImport(PQ(dependency));
        if (module) {
            if (checker.isEmpty()) {                        // Need to check smth?
                dbgScript << "No version to check, just make sure it's loaded:" << dependency;
                Py_DECREF(module);
                continue;
            }
            // Try to get __version__ from module
            // See PEP396: https://www.python.org/dev/peps/pep-0396/
            PyObject* version_obj = py.itemString("__version__", PQ(dependency));
            if (!version_obj) {
                dbgScript << "No __version__ for " << dependency
                          << "[" << plugin.name() << "]:\n" << py.lastTraceback()
                          ;
                plugin.m_unstable = true;
                reason += i18nc(
                              "@info:tooltip"
                              , "<p>Failed to check version of dependency <application>%1</application>: "
                              "Module do not have PEP396 <code>__version__</code> attribute. "
                              "It is not disabled, but behaviour is unpredictable...</p>"
                              , dependency
                          );
            }
            PyKrita::version dep_version = PyKrita::version::fromPythonObject(version_obj);
 
            if (!dep_version.isValid()) {
                // Dunno what is this... Giving up!
                dbgScript << "***: Can't parse module version for" << dependency;
                plugin.m_unstable = true;
                reason += i18nc(
                              "@info:tooltip"
                              , "<p><application>%1</application>: Unexpected module's version format"
                              , dependency
                          );
            } else if (!checker(dep_version)) {
                dbgScript << "Version requirement check failed ["
                          << plugin.name() << "] for "
                          << dependency << ": wanted " << checker.operationToString()
                          << QString(checker.required())
                          << ", but found" << QString(dep_version)
                          ;
                plugin.m_broken = true;
                reason += i18nc(
                              "@info:tooltip"
                              , "<p><application>%1</application>: No suitable version found. "
                              "Required version %2 %3, but found %4</p>"
                              , dependency
                              , checker.operationToString()
                              , QString(checker.required())
                              , QString(dep_version)
                          );
            }
            // Do not need this module anymore...
            Py_DECREF(module);
        } else {
            dbgScript << "Load failure [" << plugin.name() << "]:\n" << py.lastTraceback();
            plugin.m_broken = true;
            reason += i18nc(
                          "@info:tooltip"
                          , "<p>Failure on module load <application>%1</application>:</p><pre>%2</pre>"
                          , dependency
                          , py.lastTraceback()
                      );
        }
    }
 
    if (plugin.isBroken() || plugin.isUnstable()) {
        plugin.m_errorReason = reason;
    }
}

References dbgScript, PyKrita::version::fromPythonObject(), PythonPlugin::isBroken(), PyKrita::version_checker::isEmpty(), PythonPlugin::isUnstable(), PyKrita::version::isValid(), PyKrita::version_checker::isValid(), PyKrita::Python::itemString(), PyKrita::Python::lastTraceback(), PythonPlugin::m_broken, PythonPlugin::m_errorReason, PythonPlugin::m_unstable, PythonPlugin::name(), PyKrita::version_checker::operationToString(), parseDependency(), plugin(), PQ, PythonPlugin::property(), and PyKrita::version_checker::required().

verifyModuleExists()

bool PythonPluginManager::verifyModuleExists ( PythonPlugin & plugin )

staticprivate

Definition at line 125 of file PythonPluginManager.cpp.

{
    // Find the module:
    // 0) try to locate directory based plugin first
    QString rel_path = plugin.moduleFilePathPart();
    rel_path = rel_path + "/" + "__init__.py";
    dbgScript << "Finding Python module with rel_path:" << rel_path;
 
    QString module_path = KoResourcePaths::findAsset("pythonscripts", rel_path);
 
    dbgScript << "module_path:" << module_path;
 
    if (module_path.isEmpty()) {
        // 1) Nothing found, then try file based plugin
        rel_path = plugin.moduleFilePathPart() + ".py";
        dbgScript << "Finding Python module with rel_path:" << rel_path;
        module_path = KoResourcePaths::findAsset("pythonscripts", rel_path);
        dbgScript << "module_path:" << module_path;
    }
 
    // Is anything found at all?
    if (module_path.isEmpty()) {
        plugin.m_broken = true;
        plugin.m_errorReason = i18nc(
                                   "@info:tooltip"
                                   , "Unable to find the module specified <application>%1</application>"
                                   , plugin.moduleName()
                               );
        dbgScript << "Cannot load module:" << plugin.m_errorReason;
        return false;
    }
    dbgScript << "Found module path:" << module_path;
    return true;
}

References dbgScript, KoResourcePaths::findAsset(), PythonPlugin::m_broken, PythonPlugin::m_errorReason, PythonPlugin::moduleFilePathPart(), PythonPlugin::moduleName(), and plugin().

Member Data Documentation

m_model

PythonPluginsModel PythonPluginManager::m_model

private

Definition at line 137 of file PythonPluginManager.h.

m_plugins

QList<PythonPlugin> PythonPluginManager::m_plugins

private

Definition at line 135 of file PythonPluginManager.h.

---

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

• plugins/extensions/pykrita/plugin/PythonPluginManager.h
• plugins/extensions/pykrita/plugin/PythonPluginManager.cpp