Делаем плагины на Python!

Представляю вашему вниманию интересную статью про Python. Статья не моя (хотя кое-где я над ней поработал, надеюсь не в ущерб содержанию).
В прикрепленном файле текст статьи в html и в txt, а также некоторые скрипты к примерам.

Делаем плагины на Python
Автор: https://jenyay.net/ 

Введение

Многие программы поддерживают так называемые плагины (дополнение, расширения и т.п.), с помощью которых можно расширять функциональность программы. На Python делать программы, поддерживающие плагины особенно легко и приятно, потому что в качестве плагина могут выступать полноценные классы. Давайте посмотрим что нужно сделать, чтобы ваша программа тоже поддерживала плагины. Заодно убедимся как это легко.
Первый пример. Основные функции

Вначале давайте договоримся о структуре тестовых примеров. Модуль основной программы будет называться main.py, а плагины будут лежать в папке plugins, располагающейся рядом с этим файлом (то есть, если main.py находится , к примеру, в папке С:resource, то и папка plugins должна находиться там же.). Чтобы Python принял plugins за пакет, в нем должен находиться файл с именем __init__.py (в нашем случае он будет пустым).

Сначала представим, что динамически во время выполнения программы нам не нужно узнавать имя плагина и мы его знаем на этапе программирования. Пусть плагин имеет имя my_plugin.py и располагается в папке plugins. И пусть внутри файла my_plugin.py находится класс pluginClass, который содержит всю функциональность плагина. Вот его код:

class pluginClass(object):
def __init__(self):
pass

def run(self):
print u"Hello, Plug-in!"

В конечном итоге нам необходимо во время выполнения программы добраться до этого класса, создать его экземпляр и выполнить метод run. Для простоты на первое время договоримся, что в этом модуле нет других классов кроме pluginClass. Как бы мы поступили, если бы все имена (и модуля, и класса) были бы доступны во время программирования? Скорее всего вот так:

import plugins.my_plugin
cls = plugins.my_plugin.pluginClass()
cls.run()

И в результате получили бы сообщение "Hello, Plug-in!". А теперь вернемся к нашей задаче. Нам нужно сделать то же самое, но при этом имя модуля my_plugin и имя класса pluginClass хранится в соответствующих строковых переменных.

Импорт модуля плагина.

Аналогом встроенной директивы import является функция __import__ , она позволяет импортировать модули, имена которых на этапе написания программы неизвестны. У функции __import__ пять параметров, но обязательным является только первый. Необязательные параметры в данной статье мы использовать не будем, поэтому про них умолчим. Итак, единственный обязательный параметр - это имя пакета или модуля, который мы хотим импортировать. Если импорт пройдет удачно, функция возвратит экземпляр класса, который хранит все импортированные элементы.

Начнем с импортирования модуля. Директива import нам не поможет. Зато мы можем воспользоваться функцией __import__ . Аналогом первой строки из записанного выше примера будет следующий код:

package_obj = __import__("plugins.my_plugin")

После этого переменная package_obj станет экземпляром класса загруженного модуля (пакета) plugins. Чтобы убедиться в этом выполним команду:

print package_obj
( ! : в интерактивном режиме команда print необязательна, при вызове переменной интерпретатор "по-умолчанию" возвращает содержимое объекта, ссылка на который помещена в эту переменную путём операции присваивания "=")

При этом мы получим что-то вроде (путь, разумеется, может быть другой):
Это сообщение мало информативно, поэтому применим к переменной package_obj встроенную функцию dir, которая возвращает имеющиеся в package_obj атрибуты. Итак, выполним следующий код:

print dir(package_obj)

В результате на экран выведется такой список:

['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'my_plugin']

Обратите внимание на последний элемент списка - это и есть наш плагин. Итак, пакет мы загрузили, но как нам добраться до модуля нашего плагина? Для этого сначала воспользуемся встроенной функцией getattr, которая позволяет получить из модуля или пакета (в нашем случае package_obj) экземпляр класса атрибута (а нашем случае my_plugin). Эта функция принимает два параметра: соответственно экземпляр объекта, атрибут которого надо получить и строковую переменную, которая содержит имя атрибута. Применяя функцию getattr на пакет, в случае успеха мы получим экземпляр загруженного модуля. Выполним следующий код:

module_obj = getattr(package_obj, "my_plugin")
print module_obj

Если все прошло удачно, на экране мы увидим примерно такой результат:
Но скорее всего в программе придется загружать не один плагин, а несколько. Как в этом случае поведет себя функция __import__ ? Рассмотрим пример, в котором загружаются два плагина (все они должны находиться в папке plugins; проще всего сделать копию my_plugin.py и переименовать оба файла.).

modulename1 = "my_plugin_1"
modulename2 = "my_plugin_2"
classname = "pluginClass1"

package_obj = __import__("plugins." modulename1 )
package_obj = __import__("plugins." modulename2 )

print dir(package_obj)

В результате на экране вы увидите следующий результат:

['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'my_plugin_1', 'my_plugin_2']

В этом примере результат импорта мы каждый раз присваиваем одной и той же переменной. Но в результате после каждой операции импорта в нее добавляется новый импортированный модуль.

Получаем доступ к классу

Итак, модуль my_plugin мы загрузили ( т.е. теперь в папке plugins опять должен находиться только один файл - my_plugin.py ). Осталось добраться до класса, который содержится внутри. Для этого воспользуемся уже знакомой нам функцией dir и убедимся, что внутри действительно хранится наш класс:

print dir(module_obj)

В результате выполнения этого кода получим:

['__builtins__', '__doc__', '__file__', '__name__', 'pluginClass']

Как видим, класс pluginClass действительно содержится внутри module_obj. Снова воспользуемся функцией getattr:

obj = getattr(module_obj, "pluginClass")

В принципе, уже после этого мы можем сделать экземпляр класса pluginClass, но для начала сделаем небольшую проверку того, что мы получили. Убедимся, что полученный объект действительно является классом, причем классом, производным от object. Для этого воспользуемся встроенной функцией issubclass. Как ее использовать ясно из следующего кода:

if issubclass(obj, object):
a = obj()
a.run()
else:
print u"Not class"

Если все сделано правильно, то в результате мы увидим сообщение "Hello, Plug-in!"

И все вместе

Теперь для наглядности сведем вместе весь код, что мы раньше написали. В комментариях после операторов print приведено то, что они выведут на экран.

modulename = "my_plugin"
classname = "pluginClass"

package_obj = __import__("plugins." modulename )

print package_obj
#

print dir(package_obj)
# ['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'my_plugin']

module_obj = getattr(package_obj, modulename)

print module_obj
#

print dir(module_obj)
# ['__builtins__', '__doc__', '__file__', '__name__', 'pluginClass']

obj = getattr(module_obj, classname)

if issubclass(obj, object):
print obj
#

a = obj()

print a
#

a.run()
else:
print u"Not class"
Второй пример, приближенный к реальности

В этом примере мы заранее не будем знать ни имена модулей плагинов, ни имена классов, содержащихся внутри. А так же потребуем, чтобы все плагины были производными от базового класса baseplugin. В папке plugins кроме файла __init__.py (напоминаю, пустого) лежат еще три модуля. Один из них с именем base.py содержит в себе базовый класс:

class baseplugin (object):
def run(self):
pass

Во втором модуле my_plugin_1.py содержится один класс:

import base

class pluginClass1(base.baseplugin):
def __init__(self):
pass

def run(self):
print u"    Hello, first plug-in!"

А в третьем my_plugin_2.py два класса:

import base

class pluginClass2(base.baseplugin):
def __init__(self):
pass

def run(self):
print u"    Hello, second plug-in!"

class pluginClass3(base.baseplugin):
def __init__(self):
pass

def run(self):
print u"    Hello, third plug-in!"

Ниже располагается код, который получает имена всех файлов в папке plugins. Затем импортирует найденные модули (кроме файлов base.py и __init__.py). После этого перебирает все атрибуты внутри каждого импортированного модуля, создает экземпляры найденных внутри классов, производных от base.baseplugin и выполняет метод run.

import os

plugin_dir = "plugins"

import plugins.base

# Сюда добавляем имена загруженных модулей
modules = []

# Перебираем файлы в папке plugins
for fname in os.listdir(plugin_dir):

# Нас интересуют только файлы с расширением .py
if fname.endswith(".py"):

# Обрежем расширение .py у имени файла
module_name = fname[: -3]

# Пропустим файлы base.py и __init__.py
if module_name != "base" and module_name != "__init__":
print u"Load module " module_name

# Загружаем модуль и добавляем его имя в список загруженных модулей
package_obj = __import__(plugin_dir "."   module_name)
modules.append(module_name)

print u"dir(package_obj) = " str(dir(package_obj) )
print
else:
print u"Skip " fname

# Перебираем загруженные модули
for modulename in modules:
module_obj = getattr(package_obj, modulename)
print modulename
print dir(module_obj)

# Перебираем все, что есть внутри модуля
for elem in dir(module_obj):   
obj = getattr(module_obj, elem)

# Создаем экземпляр и выполняем функцию run
a = obj()
a.run()
print
 

Во время выполнения скрипт выводит дополнительную информацию о ходе работы. В результате на экране будут выведены следующие сообщения:

Skip base.py
Load module my_plugin_1
dir(package_obj) = ['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'base', 'my_plugin_1']

Load module my_plugin_2
dir(package_obj) = ['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'base', 'my_plugin_1', 'my_plugin_2']

Skip __init__.py
my_plugin_1
['__builtins__', '__doc__', '__file__', '__name__', 'base', 'pluginClass1']
Hello, first plug-in!

my_plugin_2
['__builtins__', '__doc__', '__file__', '__name__', 'base', 'pluginClass2', 'pluginClass3']
Hello, second plug-in!

Hello, third plug-in!
Плагины и py2sis (отредактировано)

Делаем sis

Сейчас мы научимся работать с плагинами и в том случае, если программа распространяется в виде приложения.

Для начала рассмотрим простой пример, состоящий из основного скрипта main.py и одного плагина plugin.py, расположенного в папке plugins; main.py и папка plugins ( не забудьте, кроме plugin.py в ней должен находиться также пустой файл __init__.py ) поместите в папку resource на диске C .

Основной скрипт (main.py):

import appuifw

modulename = "plugin"
classname = "pluginClass"

package_obj = __import__("plugins." modulename )
print dir(package_obj)

module_obj = getattr(package_obj, modulename)
print dir(module_obj)

obj = getattr(module_obj, classname)

def import_plugin():
if issubclass(obj, object):
a=obj()
a.run()
else:
appuifw.note (u"Not class", "error")

def exit():
if appuifw.query(u"You want exit?", "query")==1:
appuifw.app.set_exit()

appuifw.app.menu = [(u"Import plugin",import_plugin), (u"Exit",exit)]

И исходник плагина (plugin.py):

class pluginClass(object):
def __init__(self):
pass

def run(self):
from appuifw import note
note (u"Hello, Plugin!", "conf")
Если запустить файл main.py, то в консоли увидим следующее:

['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'plugin']
['__builtins__', '__doc__', '__file__', '__name__', 'pluginClass']
Hello, Plugin!

Для того, чтобы сделать sis-пакет, воспользуемся замечательной программой SmartSIS v.2.2 by smart4n:
Сразу оговорюсь, что я сам начал осваивать её только недавно (во время редактирования этой статьи), поэтому вполне допускаю, что некоторые производимые мною манипуляции можно упростить. Также у меня нет сведений о том, как выглядят и работают предыдущие и последующие версии.
Итак, запускаем программу. Те, кто знаком с ней, могут смело пропускать этот абзац. Прежде всего нужно настроить программу под себя любимого(ую):

1.) Заходим в "Функции": если меню на английском, ищем пункт Settings -> "Language" -> "Russian" -> "Функции" -> "сохранить" -> "Назад" и перезапускаем SmartSIS, о необходимости чего нас любезно и уведомляет программа.
2.) Запускаем SmartSIS, -> "Функции" -> "Настройки" и начинаем настраивать:
Рабочее место - С: или Е: - здесь всё просто: где у вас больше свободного места, тот диск и указывайте.
Оповещение - выбор способа оповещения об успешном завершении операции - определяется исключительно вашими кулинарными, музыкальными или даже, прошу прощения, сексуальными предпочтениями, одним словом, на усмотрение пользователя.
"Убить" заставку - почему-то рекомендуется поставить "Да", иначе, мол, программа зависнет - я предпочёл принять этот совет к действию.
Режим упаковки - определяет поведение программы, подробнее смотри "Помощь" -> "справка" ( в ней, кстати, есть всё, что я сейчас объясняю ) - здесь я ориентируюсь на "Пошаговый мастер".
Язык - выбор языка интерфейса - с этим пунктом мы уже знакомы.
Автоподпись - да, SmartSIS умеет ещё и подписывать только что созданные sis-пакеты, конечно, если у вас есть свой сертификат и ключ - если вы выберете "Да", тогда в оставшихся двух пунктах укажите полные пути к сертификату и ключу: например, E:certmycert.cer и E:keymykey.key. Правда, у меня не получилось наладить devcert-подпись в SmartSIS, и я пользуюсь MobileSigner by Leftup.

Настроив SmartSIS, запускаем X-plore, помещаем main.py в корень диска С (для простоты).
Также нужно создать на диске Е папку project, в ней создать папку C, в которой, в свою очередь, создаем папку resource, и в неё наконец помещаем нашу папку plugins. Таким образом путь к ней будет выглядеть так:
E:projectCresourceplugins.py.
Теперь идём в папку smartSIS на том диске, который вы определили как рабочий.
В ней создаём текстовый файл py2sis.pkg, содержащий 13 строк:

C:main.py_плюс_E:project
main
1.0.0
0x7f7e8f69
C
Vendor
default
nocaps
noautostart
None
RU
noautorun
nohidden

Пояснения (по справке SmartSIS):

1.) полный путь к скрипту дополнительные файлы(никаких пробелов между именами файлов и знаком _плюс_);
2.) название программы, которое вы будете видеть при установке программы и в меню смартфона;
3.) версия программы: major.minor.build - обязательны 3 числа (можете поставить хоть 12345.85746353.04049.98858) и точки (можно использовать запятые) между ними;
4.) UID sis, записывается в шестнадцатиричном виде;
5.) имя диска, на который будут устанавливаться необходимые файлы для скрипта;
6.) имя поставщика, то бишь автора. Обязательно замените на своё ;
7.) полный путь к иконке в SVG или MIF формате, default указывает на стандартную иконку Python;
8.) caps - для devcert приложения, nocaps - для selfcert приложения;
9.) наш sis-пакет не будет иметь функцию автозагрузки при запуске системы;
10.) если вы хотите, чтобы при установке отображался какой-нибудь текст (например, копирайт автора), то укажите полный путь к текстовому файлу (кодировки Win 1251, Unicode, utf-8) размером не более 1-го кбайта (Nоnе означает, что по-умолчанию текст отсутствует);
11.) код языка с которым будет упакован sis-пакет;
12.) программа НЕ будет запускаться автоматически после установки sis-пакета;
13.) программа НЕ будет скрытой в меню.
Для получения более подробной информации читайте справку в SmartSIS.

Создав py2sis.pkg, возвращаемся в SmartSIS.
Выбираем "Функции" -> "Инструменты"
-> "py2sis". Если вы не допустили ошибок, py2sis запустится и выдаст информацию, извлечённую из py2sis.pkg. Проверьте её, если всё правильно (обратите особое внимание на то, включена ли папка plugins и её содержимое в список), то "Функции" -> "Упаковать". После окончания упаковки вы увидите, полный путь к упакованному sis-пакету.

Возвращаемся в X-plore и в папке !:smartSISpacked находим наш sis-пакет, который можно сразу устанавливать, если вы доверили SmartSIS подпись, в противном случае подписываете сами. Далее идём в меню смартфона, запускаем нашу программу main -> "Функции" -> "Import plugin" и убеждаемся, что не напрасны были наши труды.
Естественно main.py и plugin.py можно изменять, причём если в случае изменения main придётся повторять упаковку, то plugin.py изменять очень просто: идём в папку !:resourceplugins, открываем plugin.py, редактируем (например, пишем вместо "Hello, Plugin!" - "Hello, User!") и, вуаля, мы имеем новый плагин с новой функциональностью (, в чём можно убедиться, повторив "Import plugin" !

Таким образом, мы с вами сделали, грубо говоря, своеобразную программу-оболочку, которая, не имея почти никакой функциональности, тем не менее за счёт возможности импорта плагина может свою функциональность расширять, причём делать это, согласитесь, довольно удобно.

Плагины и дополнительные модули

Давайте теперь сделаем полноценное приложение из примера, рассмотренного в разделе "Второй пример, приближенный к реальности", но с небольшим усложнением. Предположим, что один из плагинов импортирует другой модуль Python, который не импортирует основная программа. Пусть, для примера, одному из плагинов понадобится библиотека Xoltar toolkit (автор Bryn Keller)( я недавно выкладывал в раздел Документация/статьи 3 статьи о функциональном программировании на Python (автор David Mertz), кому интересно - можете поискать), а конкретно её модуль functional. В этом случае его код будет выглядеть вот так:

import base
import functional
from appuifw import note

class functionalpluginClass(base.baseplugin):
def __init__(self):
pass

def run(self):
note(u"    Hello, FP!", "conf")
Заключение

Итак, мы научились делать так, чтобы наша программа умела динамически загружать модули (плагины), а также сделали полноценное приложение. Вот, собственно, и все, что хотелось рассказать

Статья скачана с сайта https://www.realcoding.net/ , адаптирована (там, где нужно и можно было это сделать) для Python S60 мною.
К сожалению, последнюю часть материала пришлось изменять, так как в ней идёт речь о том, как сделать windows-приложение с помощью библиотеки py2exe (что несколько неактуально для смартфонов , пришлось обдумывать "наш ответ капитализму"

Спасибо автору за написанную статью, обязательно посмотрите оригинал.

#------- Удачи! -------#

Прикрепленный файл: 1936_make_plugins..zip (20.20 кб)