• Книги
• WxPythonInAction
• Упрощение работы в wxPython при помощи PyCrust

Упрощение работы в wxPython при помощи PyCrust

Эта глава включает:

• Взаимодействие с wxPython-программой

• Рассмотрение возможностей PyCrust

• Сопряжение PyCrust с wxPython-приложением

• Работа с GUI и вспомогательными модулями PyCrust

• Взаимодействие wxPython-программы с модулями PyCrust

PyCrust – это написанная на wxPython графическая оболочка, которую Вы можете использовать для анализа wxPython-программ.

Почему она названа PyCrust? Когда Патрик О'браен (Patrick O’Brien), используя wxPython, создавал диалоговую Python-оболочку, очевидно название «PyShell» уже было использовано. Вместо него выбор пал на «PyCrust».

PyCrust – это часть большого пакета Py, который включает дополнительные программы со связанными функциональными возможностями, включая PyFilling, PyAlaMode, PyAlaCarte и PyShell.

Общая идея этих программ - комбинация возможностей визуальной графической (point-and-click) среды, интерактивности wxPython и самоуправления (интроспективность) при выполнении. В отличие от любой из Py-программ, которые усиливают эту комбинацию, PyCrust представляет более полную реализацию этой идеи.

В этой главе, мы покажем Вам, что делают PyCrust и связанные с ним программы, и как Вы можете их использовать, чтобы сделать Вашу работу с потоком wxPython более равномерной. Сначала мы поговорим об обычной Python-оболочке, затем собственно о PyCrust, и, наконец, мы охватим остальные программы в пакете Py.

Как взаимодействовать с wxPython-программой?

Неизменная особенность Python в сравнении с другими языками программирования, состоит в том, что его можно использоваться двумя способами: Вы можете запускать на выполнение существующие Python-программы, или же запустить Python в интерактивном режиме командной строки. Выполнение Python в интерактивном режиме подобно диалогу с Python-интерпретатором. Вы вводите строку кода и нажимаете Enter. Python выполняет этот код, выдает ответ и запрашивает у Вас следующую строку. Такой интерактивный режим существенно отличает Python от таких языков, как C++, Visual Basic или Perl. Имея такой интерпретатор, нет необходимости, чтобы сделать простые вещи, писать в wxPython цельную программу. Фактически, Вы можете даже использовать диалоговый Python как настольный калькулятор.

В листинге 4.1 мы запустили Python в режиме командной строки и выполнили небольшие математические вычисления. Python стартует, отображая несколько строк информации, сопровождаемых его основным приглашением (>>>). Когда Вы введёте, что-нибудь, что потребует дополнительных строк кода, Python покажет вторичное приглашение (...).

Листинг 4.1 Пример интерактивного сеанса Python

   1 $ Python
   2 Python 2.3.3 (#1, Jan 25 2004, 11:06:18)
   3 [GCC 3.2.2 (Mandrake Linux 9.1 3.2.2-3mdk)] on linux2
   4 Type "help", "copyright", "credits" or "license" for more information.
   5 >>> 2 + 2
   6 4
   7 >>> 7 * 6
   8 42
   9 >>> 5 ** 3
  10 125
  11 >>> for n in range(5):
  12 ... print n * 9
  13 ...
  14 0
  15 9
  16 18
  17 27
  18 36
  19 >>>

Диалоговый Python – это не только хороший настольный калькулятор, но и великолепный инструмент для обучения, так как обеспечивает немедленную ответную реакцию. Если Вы в чем-то сомневаетесь, Вы можете просто запустить Python, ввести несколько строк исследуемого кода, посмотреть реакцию Python и привести в соответствие основной код. Один из лучших способов изучения работы существующего кода Python – испытание его в интерактивном режиме.

PyCrust устанавливает стандарт оболочки Python

Когда Вы работаете с Python в интерактивном режиме, Вы работаете в среде, называемой Python-оболочкой, которая подобна другим средам, типа окна DOS на платформах Microsoft или командной строке bash в Unix-системах.

Основа всех Python-оболочек, которую Вы видите, когда запускаете Python из командной строки, такая же, как и в листинге 4.1. Хотя Python и полезная оболочка, она полностью ориентирована на текстовый, а не графический режим, и не обеспечивает всех клавиатурных комбинаций (shortcuts) или всплывающих подсказок (hints), которые способен предоставить Python. Чтобы предоставить эти дополнительные функциональные возможности, были специально разработаны несколько графических Python-оболочек. Наиболее общеизвестный является интегрированная среда разработки IDLE (Integrated DeveLopment Environment), которая является стандартной частью дистрибутива Python. Оболочка IDLE, как показано на рисунке 4.1, выглядит подобно оболочке командной строки Python, но имеет дополнительные графические возможности, подобные подсказкам о вызове (calltips).

Другие инструменты для разработки на Python, типа PythonWin или Boa Constructor, имеют графическую оболочку Python, подобную той, что и в IDLE. Существование всех этих оболочек, подтолкнуло к созданию PyCrust. Хотя каждая из инструментальных оболочек имеет некоторые полезные возможности, например, повторный вызов команды, автозавершение и подсказки о вызове, нет инструмента, который бы имел полный набор всех этих возможностей. Одна из целей PyCrust состоит в том, чтобы обеспечить полный набор возможностей всех существующих оболочек Python.

Рисунок 4.1 Оболочка IDLE предоставляет для функций и методов подсказки о вызове

Другой причиной, по которой был создан PyCrust, было то, что инструментальные средства, написанные при помощи одной GUI-библиотеки, часто не работают с кодом от другой GUI-библиотеки. Например, IDLE написан с помощью Tkinter, а не wxPython. До недавнего времени, если бы Вы попытались импортировать и использовать модуль wxPython из Python-оболочки IDLE, Вы бы получили конфликт между циклом событий wxPython и циклом событий Tkinter, что привело бы к останову или краху программы.

В действительности, эти два комплекта инструментов соперничают за право управления циклом событий. Поэтому, если Вам необходимы возможности самоуправления при выполнении, реализованные в модулях wxPython, Ваша Python-оболочка должна быть написана на wxPython. Поскольку не существует Python-оболочки, поддерживающей все множество возможностей, для того чтобы удовлетворить такую потребность, был создан PyCrust.

Какие у PyCrust полезные возможности?

Теперь мы рассмотрим некоторые возможности, которые предоставляет оболочка PyCrust. PyCrust выглядит знакомым, т. к. отображает те же самые строки информации и использует те же сообщения, что и командная строка оболочки Python. Рисунок 4.2 показывает открытый экран PyCrust.

Вы заметите, что фрейм PyCrust, содержащий элемент wx.SplitterWindow, разделен на две секции: верхняя секция напоминает обычную оболочку Python, нижняя секция содержит элемент управления Notebook, который включает разнообразные ярлыки, показывающие информацию о текущем пространстве имен (namespace). Верхняя секция (PyCrust-оболочка), имеет несколько полезных возможностей, обсуждаемых в следующих нескольких подразделах.

Рисунок 4.2 Запущенный PyCrust показывает оболочку и интерфейс на основе ярлыков записной книжки

Автозавершение

Когда Вы вводите имя объекта, завершаемое оператором-точкой, происходит автозавершение. PyCrust показывает алфавитный список всех известных атрибутов данного объекта. Если Вы введете дополнительные буквы, подсвеченный выбор в списке изменится, и будет соответствовать введенным Вами буквам. Если нужный Вам элемент выделен, нажмите клавишу Tab и PyCrust заполнит за Вас остальную часть имени атрибута.

На рисунке 4.3 PyCrust показывает список атрибутов для объекта строки. Список автозавершения включает все свойства и методы этого объекта.

Рисунок 4.3 Отображение атрибутов объекта при автозавершении

Подсказки о вызове (Calltip) и параметры по умолчанию

Когда Вы вводите левую круглую скобку после имени вызываемого объекта, PyCrust показывает окно подсказки о вызове (calltip) (см. рисунок 4.4) с информацией о передаваемых при вызове аргументах и справочной информацией по этому вызову (если она имеется).

Вызываемый объект может быть функцией, методом, встроенной командой или классом. Все они могут принимать аргументы и могут иметь справочную информацию, предоставляющую сведения о том, что элемент делает и какой тип возвращаемого значения. Эта информация выводится во временном окне, выше или ниже знака каретки, что устраняет потребность обращаться к документации. Если Вы знаете, как использовать объект вызова, игнорируйте подсказку о вызове и продолжайте ввод.

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

Рисунок 4.4 Подсказка о вызове выводит информацию о вызываемом объекте

Выделение синтаксиса

При вводе кода в оболочку PyCrust изменяет цвет текста в зависимости от его значения. Например, ключевые слова Python появляются в одном цвете, значения текстовых строк в другом, а комментарии в третьем. Это обеспечивает визуальное подтверждение того, что Вы не пропустили каких-либо закрывающих кавычек или не написали с орфографической ошибкой ключевое слово Python.

Многие возможности PyCrust делают возможным поставляемое с wxPython мощное управление текстом. Компонент wx.stc.StyledTextCtrl - wxPython обертка на исходном коде компонента редактирования Scintilla, разработанная Нейлом Ходсоном (Neil Hodgson). Scintilla (www.scintilla.org) используется различными приложениями редактирования исходного кода, включая поставляемые с wxPython демонстрационные программы. Хотя и было бы не легко создать функциональность редактора исходного кода подобную оболочке wxPython, но создать PyCrust без Scintilla было бы практически невозможно.

Помощь по языку Python

PyCrust обеспечивает полную поддержку функций справочной системы по языку Python. Как показано на рисунке 4.5, функция помощи выводит информацию практически обо всех аспектах Python.

Рисунок 4.5 Использование внутри PyCrust функции помощи по Python

Функцию помощи по языку Python обеспечивает дополнительное приглашение (help). После использования помощи, введя quit в ответ на приглашение help, Вы можете покинуть этот режим и вернуться к обычному Python.

Повторный вызов команды

Есть много способов избежать ввода внутри PyCrust. Большинство из них включают в себя запоминание всего того, что Вы предварительно ввели, внесение необходимых изменений и отсылку результата интерпретатору Python. Например, PyCrust поддерживает историю всех команд, которые Вы ввели в текущем сеансе работы. Вы можете повторно вызвать из истории команд любую предварительно введенную команду Python (однострочную или многострочную). Таблица 4.1 показывает список клавиатурных комбинаций, которые касаются этих функциональных возможностей.

Таблица 4.1 Клавиатурные комбинации повторного вызова команд оболочки PyCrust

Как Вы видите, отдельные команды для восстановления и вставки старых команд различаются тем, как PyCrust обращается с текстом, введенным в текущем запросе wxPython. Для замены введенного Вами текста используйте одну из комбинаций, которая извлекает элемент истории. Используйте одну из комбинаций для вставки элемента истории, чтобы вставить старую команду в позицию каретки.

Вставка строки в середину многострочной команды работает по-другому, чем вставка в команду однострочной команды. Нажимая клавишу Enter, Вы не можете вставить строку в многострочную команду, потому что она посылает текущую команду интерпретатору Python. Вместо этого, чтобы вставить разрыв на текущей строке, нажмите Ctrl+Enter. Если Вы находитесь в конце строки, за текущей строкой вставляется пустая строка. Этот процесс похож на вырезание и вставку текста в обычном текстовом редакторе.

Заключительный метод повторного вызова команды состоит в том, чтобы просто переместить каретку на команду, которую Вы хотите вызвать и нажать Enter. PyCrust скопирует эту команду в текущую позицию ввода Python, и поместит каретку в конец. Вы сможете затем изменить команду или снова нажать Enter и послать команду интерпретатору.

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

Вырезание (Cut) и вставка (Paste)

Иногда Вам может потребоваться использовать разработанный в оболочке код без необходимости его повторного ввода. В других случаях, Вы можете найти образец кода, возможно в онлайновом руководстве и использовать его в Python-оболочке. PyCrust предоставляет несколько простых операций вырезания и вставки, перечисленных в таблице 4.2.

Таблица 4.2 Клавиатурные комбинации вырезания и вставки оболочки PyCrust

Другая особенность операции вставки состоит в том, что PyCrust распознает и автоматически удаляет из любого кода, вставляемого в PyCrust-оболочку, стандартные приглашения Python (>>>). Это облегчает копирование образцов кода из руководства или почтового сообщения, вставку и использование его в PyCrust без необходимости делать ручную чистку.

Иногда, когда Вы копируете код, Вам может понадобиться удалить приглашения PyCrust, как например, при копировании кода в ваши исходные файлы. В другой раз, Вы захотите сохранить приглашения, например, когда Вы копируете примеры в какой-либо документ или отправляете в группу новостей. PyCrust обеспечивает оба варианта при копировании текста из оболочки.

Стандартное окружение оболочки

В максимально возможной степени в пределах среды wxPython, PyCrust ведет себя так же, как и Python-оболочка командной строки. Имеются в виду некоторые необычные ситуации, как например, травление (pickling) экземпляров классов, которые определены в рамках сеанса оболочки. Единственная область, где PyCrust даёт сбой, кроется в его способности замещать функциональные возможности командной строки, являющиеся клавиатурными прерываниями. Как только код Python введен в PyCrust-оболочку, нет возможности прервать его выполнение. Например, предположим, Вы закодировали в PyCrust бесконечный цикл, как в следующем примере:

   1 >>> while True:
   2 ...    print "Hello"
   3 ...

После того, как Вы нажмете Enter, и код отправится интерпретатору Python, PyCrust приостановит ответную реакцию. Чтобы прерывать бесконечный цикл, завершите программу PyCrust. Этот недостаток PyCrust - отличие от Python-оболочки командной строки, которая сохраняет способность обрабатывать клавиатурное прерывание (Ctrl+C). В Python-оболочке командной строки Вы увидели бы следующее поведение:

   1 >>> while True:
   2 ...    print "Hello"
   3 ...
   4 Hello
   5 Hello
   6 Hello
   7 Hello
   8 Hello
   9 Hello
  10 Hello
  11 Hello
  12 Hello
  13 Hello
  14 Hello
  15 Traceback (most recent call last):
  16   File "<stdin>", line 2, in ?
  17 KeyboardInterrupt
  18 >>>

Механизм обработки событий в GUI среде чрезвычайно затрудняет решение, которое позволило бы PyCrust преодолеть бесконечный цикл или прервать любую длительно исполняемую последовательность введенного в приглашение оболочки кода. Будущая версия PyCrust может обеспечить решение этого вопроса. Между тем, помните об этом поведении. К счастью, это единственное известное различие между PyCrust и стандартной командной оболочкой. Во всех других отношениях, оболочка PyCrust работает точно так же, как и оболочка командной строки Python.

Динамическое обновление

После запуска оболочки PyCrust все ее возможности динамически обновляются, и такие свойства как автозавершение и подсказка о вызове будут доступными даже для объектов, определяемых при непосредственном вводе команд и данных в строке приглашения оболочки. Например, посмотрите показанные на рисунках 4.6 и 4.7 сеансы, где мы определяем и используем класс.

На рисунке 4.6 PyCrust показывает доступные для нового класса варианты автозавершения.

На рисунке 4.7 PyCrust показывает подсказку о вызове для недавно определенного метода класса.

Рисунок 4.6 Динамически генерированная PyCrust информация автозавершения

Рисунок 4.7 Динамически генерированная PyCrust информация подсказки о вызове

Это иллюстрирует реализуемый PyCrust способ динамического выполнения Python, который невозможен в других языках программирования со статическим вводом и компиляцией.

Каково назначение страниц PyCrust?

В нижней половине интерфейса PyCrust расположен элемент наподобие блокнота (notebook), который включает несколько страниц полезной информации. Появляющаяся при старте страница PyCrust – это Namespace (пространство имен).

Страница Namespace (Пространство имен)

Показанная на рисунке 4.8 страница Namespace, разделена на две части, где снова используется элемент wx.SplitterWindow. Левая сторона содержит элемент управления деревом, который отображает текущее пространство имен, а правая сторона отображает информацию о текущем объекте, выбранном в дереве пространства имен.

Рисунок 4.8 Дерево пространства имен PyCrust позволяет погружаться в объекты и инспектировать их атрибуты

Дерево Namespace представляет иерархический вид всех объектов в текущем пространстве имен. В нем содержатся пункты, которые возвращаются при работе встроенной функции Python locals(). На рисунке 4.8, мы импортировали пакет wx и выбрали его в дереве пространства имен. Правая сторона отображает имя выбранного элемента, его тип и текущее значение. Если объект имеет ассоциированный с ним исходный код, PyCrust также его отображает. В этом случае, wx является пакетом wxPython, поэтому PyCrust отображает исходный код из файла init.py, который находится в директории wx. Первая строка экрана предоставляет имя объекта, полностью пригодное, для операций вырезания и вставки в оболочку PyCrust или в исходный код Вашего приложения. Например, если Вы импортируете и откроете модуль locale, Вы можете достичь элементов этого модуля, сохраненных внутри атрибута словаря encoding_alias. Как только Вы выберете один из этих элементов, Вы можете вырезать и вставлять его отображаемое имя непосредственно в оболочку PyCrust, например следующим образом:

   1 >>> import locale
   2 >>> locale.encoding_alias['en']
   3 'ISO8859-1'
   4 >>>

В этом случае, PyCrust снабдил нас полностью пригодным именем (locale.encoding_alias['en']), использующим индексную нотацию Python (['en']) для ссылки на определенный пункт словаря encoding_alias. Этот механизм также работает и для списков. Если Вы что-то указываете в дереве пространства имен для ссылки в своем коде, PyCrust даёт Вам точный синтаксис для выполнения этой задачи.

Страница Display (Экран)

Страница Display отображает красивый вид объекта. PyCrust имеет встроенную функцию pp(), которая использует модуль качественной печати Python (pprint) для выполнения хорошо отформатированного вида любого объекта wxPython. Информация на странице Display корректируется при каждом обновлении отображаемого объекта, не требуя от Вас явного импортирования и многократного использования pprint.

Например, чтобы увидеть, как изменяется содержимое списка при манипулировании им в оболочке, Вы можете выделить страницу Display, использовать функцию pp() в пределах оболочки для отображения Вашего объекта списка на странице Display, а затем запустить код, который модифицирует этот список. Всякий раз, когда список будет изменяться, изменения сразу же будут появляться на странице Display.

Страница Calltip (Подсказка о вызове)

Страница Calltip отображает содержание последней подсказки о вызове Python-оболочки. Выберите страницу Calltip, если Вы работаете с вызываемыми объектами, которые требуют большого количества передаваемых им параметров. При использовании пакета wxPython существует много классов, которые могут иметь много методов, принимающих множество параметров. Например, для создания wx.Button, Вы можете передать вплоть до восьми параметров, один из которых обязателен, тогда как другие семь имеют значение по умолчанию. Страница Calltip отображает следующую информацию о конструкторе wx.Button:

   1 __init__(self, Window parent, int id=-1, String label=EmptyString,
   2    Point pos=DefaultPosition, Size size=DefaultSize,
   3    long style=0, Validator validator=DefaultValidator,
   4    String name=ButtonNameStr) -> Button
   5 Create and show a button. The preferred way to create standard buttons
   6 is to use a standard ID and an empty label. In this case wxWigets will
   7 automatically use a stock label that corresponds to the ID given. In
   8 addition, the button will be decorated with stock icons under GTK+2.

Поскольку классы wxPython в действительности надстроены над классами C++, информация для подсказок о вызове основывается только на документации класса (docstrings). Она сгенерирована, чтобы показать требуемые базовому классу C++ состав передаваемых параметров и их тип (int, string, point и т.д.). Вот почему подсказка о вызове конструктора wx.Button показывается таким способом.

PyCrust инспектирует объекты, полностью определенные на языке Python, полагаясь на характер их аргументов.

Страница Session (Сеанс)

Страница Session (в новых версиях – History (История)) является простым текстовым элементом, который перечисляет все команды, введенные в текущем сеансе оболочки. Это облегчает вырезание и вставку команд для использования где-нибудь еще, при этом нет необходимости удалять отклик, который возвращается интерпретатором wxPython.

Страница Dispatcher (Диспетчер)

PyCrust включает модуль, названный dispatcher, предоставляющий механизм для свободного связывания объектов внутри приложения. PyCrust использует диспетчер, чтобы держать аспекты своего интерфейса актуальными, когда команды посылаются из оболочки в интерпретатор Python. Страница Dispatcher (рисунок 4.9) содержит информацию о сигналах, проходящих через механизм диспетчеризации. Прежде всего это полезно при работе непосредственно с PyCrust.

Страница Dispatcher также иллюстрирует, как добавить другую страницу в элемент wx.Notebook. Приведенный ниже исходный код отображаемого на странице Dispatcher элемента управления текстом, показывает, как может быть использован модуль диспетчера:

   1 class DispatcherListing(wx.TextCtrl):
   2     """Text control containing all dispatches for session."""
   3     def __init__(self, parent=None, id=-1):
   4         style = (wx.TE_MULTILINE | wx.TE_READONLY |
   5             wx.TE_RICH2 | wx.TE_DONTWRAP)
   6         wx.TextCtrl.__init__(self, parent, id, style=style)
   7         dispatcher.connect(receiver=self.spy)
   8     def spy(self, signal, sender):
   9         """Receiver for Any signal from Any sender."""
  10         text = '%r from %s' % (signal, sender)
  11         self.SetInsertionPointEnd()
  12         start, end = self.GetSelection()
  13         if start != end:
  14             self.SetSelection(0, 0)
  15         self.AppendText(text + '\n')

Теперь, когда Вы увидели, что может делать PyCrust как автономная оболочка Python и инспектор пространства имен, давайте взглянем на некоторые приемы использования PyCrust в Ваших собственных программах wxPython.

Рисунок 4.9 Диспетчер PyCrust информирует о том, каким образом команды передаются интерпретатору Python

Как связать PyCrust с моим wxPython-приложением?

Допустим, Вы использовали wxPython для создания программы, Ваша программа работает, и теперь Вы хотели бы лучше понять, как именно она работает. В этой главе Вы увидели возможности PyCrust и они могут оказаться очень полезными для понимания функционирования Вашей программы. Но Вам не хотелось бы изменять программу только для того, чтобы использовать ее с PyCrust. Что же делать в этом случае?

Передавая имя Вашей программы утилите PyWrap, Вы сможете без изменений ее запустить под оболочкой PyCrust. Листинг 4.2 показывает программу spare.py, которую мы подготовили для связи с PyCrust.

Листинг 4.2 Программа spare.py, подготовленная для связи с PyCrust

   1 #!/usr/bin/env python
   2 """Spare.py is a starting point for simple wxPython programs."""
   3 import wx
   4 
   5 class Frame(wx.Frame):
   6     pass
   7 class App(wx.App):
   8     def OnInit(self):
   9          self.frame = Frame(parent=None, id=-1, title='Spare')
  10          self.frame.Show()
  11          self.SetTopWindow(self.frame)
  12          return True
  13 if __name__ == '__main__':
  14     app = App()
  15     app.MainLoop()

Для запуска этой программы в окружении PyCrust, передайте имя программы в PyWrap из каталога, где находится spare.py. Командная строка под Linux выглядит так:

$ pywrap spare.py

Когда PyWrap стартует, он попытается импортировать модуль, включенный в командную строку. Затем PyWrap ищет в этом модуле подкласс wx.App и создает экземпляр этого класса. После этого создает окно PyWrap wx.py.crust.CrustFrame с оболочкой, открывает прикладной объект в дереве пространства имен PyCrust и запускает цикл событий wxPython.

Полный исходный код для PyWrap приведен в листинге 4.3. Это пример того, как много функциональных возможностей можно добавить в Вашу программу, используя небольшое количество дополнительного кодекса.

Листинг 4.3 Исходный код PyWrap.py

   1 """PyWrap is a command line utility that runs a python
   2 program with additional runtime tools, such as PyCrust."""
   3 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   4 __cvsid__ = "$Id: PyCrust.txt,v 1.15 2005/03/29 23:39:27 robind Exp $"
   5 __revision__ = "$Revision: 1.15 $"[11:-2]
   6 import os
   7 import sys
   8 import wx
   9 from wx.py.crust import CrustFrame
  10 def wrap(app):
  11     wx.InitAllImageHandlers()
  12     frame = CrustFrame()
  13     frame.SetSize((750, 525))
  14     frame.Show(True)
  15     frame.shell.interp.locals['app'] = app
  16     app.MainLoop()
  17 def main(modulename=None):
  18     sys.path.insert(0, os.curdir)
  19     if not modulename:
  20         if len(sys.argv) < 2:
  21              print "Please specify a module name."
  22              raise SystemExit
  23         modulename = sys.argv[1]
  24         if modulename.endswith('.py'):
  25              modulename = modulename[:-3]
  26     module = __import__(modulename)
  27     # Find the App class.
  28     App = None
  29     d = module.__dict__
  30     for item in d.keys():
  31         try:
  32              if issubclass(d[item], wx.App):
  33                   App = d[item]
  34         except (NameError, TypeError):
  35              pass
  36     if App is None:
  37         print "No App class was found."
  38         raise SystemExit
  39     app = App()
  40     wrap(app)
  41 if __name__ == '__main__':
  42     main()

После запуска команды PyWrap будут отображены как простой фрейм из spare.py, так и фрейм PyCrust.

PyCrust в действии

Теперь давайте посмотрим, что мы можем сделать с прикладным фреймом из оболочки PyCrust. Рисунок 4.10 отображает результат. Сначала мы spare.py импортируем wx и добавим в наш фрейм панель:

   1 >>> import wx
   2 >>> app.frame.panel = wx.Panel(parent=app.frame)
   3 >>> app.frame.panel.SetBackgroundColour('White')
   4 True
   5 >>>

Рисунок 4.10 Использование PyWrap для оптимизации выполнения wxPython-программы

Добавленная к фрейму панель имеет по умолчанию серый цвет, затем он изменен на белый. Однако, установка цвета фона панели не проявляется немедленно. Для этого нужно инициировать событие, которое заставит панель перерисовать себя на основании свойства ее нового фонового цвета. Единственный способ инициировать это событие – потребовать, чтобы панель себя обновила:

   1 >>> app.frame.panel.Refresh()

Теперь белая панель отображена, и мы на один шаг ближе к пониманию деталей того, как действительно работает wxPython.

Давайте добавим еще и строку состояния (status bar):

   1 >>> app.frame.statusbar = app.frame.CreateStatusBar(number=3)
   2 >>> app.frame.statusbar.SetStatusText("Left", 0)
   3 >>> app.frame.statusbar.SetStatusText("Center", 1)
   4 >>> app.frame.statusbar.SetStatusText("Right", 2)

Заметьте, как строка состояния появляется в пределах фрейма, не изменяя самые крайние размеры фрейма. Также, обратите внимание, что добавленный в каждую из трех секций текст строки состояния появляется немедленно и не требует обновления. Теперь давайте добавим меню и строку меню (menubar):

   1 >>> app.frame.menubar = wx.MenuBar()
   2 >>> menu = wx.Menu()
   3 >>> app.frame.menubar.Append(menu, "Primary")
   4 True
   5 >>> app.frame.SetMenuBar(app.frame.menubar)
   6 >>> menu.Append(wx.NewId(), "One", "First menu item")
   7 <wx.core.MenuItem; proxy of C++ wxMenuItem instance at
   8   _d8043d08_p_wxMenuItem>
   9 >>> menu.Append(wx.NewId(), "Two", "Second menu item")
  10 <wx.core.MenuItem; proxy of C++ wxMenuItem instance at
  11   _40a83e08_p_wxMenuItem>
  12 >>>

Когда Вы манипулируете своими wxPython-объектами в оболочке PyCrust, помните о влиянии этих изменений на Вашу выполняемую программу. Попытайтесь ответить на следующие вопросы. Когда меню действительно появляется в пределах фрейма? Какие атрибуты меню Вы можете изменить, пока выполняется программа? Можете ли Вы добавить дополнительные пункты меню? Можете ли Вы удалить их? Можете ли Вы их блокировать? Изучение всех этих возможностей должно помочь лучше понять wxPython и обеспечить Вас большей уверенностью, когда придет время записи фактического программного кода.

Теперь, когда мы потратили большую часть главы на обсуждение PyCrust, мы готовы пойти на прогулку через остальную часть компонентов пакета Py.

Что еще имеется в пакете Py?

Все программы PyCrust просто используют включенные в пакет Py модули Python, например, такие как shell.py, crust.py, introspect.py и interpreter.py. Эти программы являются строительными блоками, которые использованы для создания PyCrust и Вы можете использовать их раздельно или вместе.

Считайте, что PyCrust представляет одно направление трансляции битов и частей функционального наполнения, содержащегося в пакете Py. PyShell представляет другое направление, а PyAlaMode - третье. В каждом из этих случаев, большая часть основного кода является общей для всех них с некоторым отдаленным изменением контейнеров. Поэтому считайте пакет Py библиотекой модулей, которые Вы можете собрать, как Вам нравится, и где бы Вы хотели отобразить оболочку wxPython, в редакторе кода или в информации времени выполнения в пределах Вашей программы.

Внутри пакета Py существует четкое разделение между модулями, обеспечивающими функциональность интерфейса пользователя и другими модулями. Такое разделение значительно облегчает использование этих модулей в Ваших собственных программах. Все модули, начинающиеся с Py, например, PyCrust, PyShell, PyAlaMode и PyAlaCarte – это GUI программы конечного пользователя. У вас не будет необходимости импортировать в Ваши программы какой-нибудь из этих модулей. Следующий параграф описывает модули конечного пользователя.

Работа с GUI-программами

Программы пользовательского уровня является пакетами, которые поддерживают модули различными путями. Таблица 4.3 приводит описание программ пользовательского уровня.

Таблица 4.3 Программы конечного пользователя, включенные в пакет Py

Работа с модулями поддержки

Модули поддержки обеспечивает базовую функциональность программ конечного пользователя, и могут быть импортированы в Ваши собственные программы. Эти модули являются по существу строительными блоками для создания Py-программ пользовательского уровня. Таблица 4.4 содержит перечень модулей поддержки, являющихся частью пакета Py, вместе с их кратким описанием.

Таблица 4.4 Модули поддержки пакета Py

Модуль buffer

Модуль buffer содержит класс Buffer, который поддерживает обычное редактирование файла. Буфер имеет методы такие, как new(), open(), hasChanged(), save() и saveAs(). Обрабатываемый посредством буфера файл представлен экземпляром класса Document, определенного в модуле document. Фактическое редактирование содержимого файла происходит посредством одного или более экземпляров класса Editor, определенного в модуле editor. Буфер действует как посредник между одним или более редакторами и фактически представляет физический файл.

Уникальная характерная особенность класса Buffer состоит в том, что каждому экземпляру буфера назначается отдельный экземпляр интерпретатора Python. Эта возможность позволяет использовать буферы в приложениях, которым нужно предоставить функции автозавершения, подсказки о вызове и другие вспомогательные вещи стадии выполнения при редактировании файлов исходного кода Python. Каждый буфер интерпретатора полностью независим и обновляется при вызове метода буфера updateNamespace(). Листинг 4.4 приводит исходный код этого метода.

Листинг 4.4 Метод буфера для обновления пространства имен

   1 def updateNamespace(self):
   2     """Update the namespace for autocompletion and calltips.
   3     Return True if updated, False if there was an error."""
   4     if not self.interp or not hasattr(self.editor, 'getText'):
   5          return False
   6     syspath = sys.path
   7     sys.path = self.syspath
   8     text = self.editor.getText()
   9     text = text.replace('\r\n', '\n')
  10     text = text.replace('\r', '\n')
  11     name = self.modulename or self.name
  12     module = imp.new_module(name)
  13     newspace = module.__dict__.copy()
  14     try:
  15          try:
  16               code = compile(text, name, 'exec')
  17          except:
  18               raise
  19          try:
  20               exec code in newspace
  21     except:
  22         raise
  23     else:
  24         # No problems, so update the namespace.
  25         self.interp.locals.clear()
  26         self.interp.locals.update(newspace)
  27         return True
  28     finally:
  29         sys.path = syspath
  30         for m in sys.modules.keys():
  31             if m not in self.modules:
  32                 del sys.modules[m]

Данный метод формирует текст в редакторе при помощи встроенного метода Python compile, а затем выполняет его, используя ключевое слово exec. Если компиляция успешна, результат устанавливает количество переменных в пространстве имен newspace. В результате выполнения, при обновлении локального пространства имен интерпретатора, обеспечивается доступ интерпретатора к любым определенным в буфере редактора классам, методам или переменным.

Модуль crust

Модуль crust содержит шесть характерных для программного приложения PyCrust элементов GUI. Основной класс CrustFrame является подклассом wx.Frame. Если Вы просмотрите листинг 4.1, то можете увидеть, как программа PyWrap импортирует CrustFrame и создает его экземпляр. Это самый простой способ вставить фрейм PyCrust в Вашу собственную программу. Если Вы хотите что-то меньшее, чем целый фрейм, можете использовать один или несколько классов, указанных в таблице 4.5.

Таблица 4.5 Классы, определенные в модуле crust

Эти GUI-элементы интерфейса могут быть использованы в любой программе wxPython и обеспечивают полезными интроспективными визуальными возможностями.

Модуль dispatcher

Диспетчер обеспечивает услуги глобальной обработки сигналов. Это означает, что он действует как посредник, разрешая объектам посылать и получать сообщения, без необходимости что-либо знать друг о друге. Все что им нужно знать - это посылаемый сигнал (обычно простая строка). Один или несколько объектов могут запросить, чтобы диспетчер уведомлял их всякий раз, когда сигнал посылается, и один или несколько объектов могут указать диспетчеру послать некоторый конкретный сигнал.

Листинг 4.5 иллюстрирует, почему диспетчер такой полезный. Поскольку все Py-программы построены на одних и тех же основных модулях, оба, и PyCrust и PyShell используют почти идентичный код. Единственное различие в том, что PyCrust включает блокнотный элемент с дополнительными функциями, подобно дереву пространства имен, обновляемый всякий раз, когда интерпретатору посылаются команды. Интерпретатор использует диспетчера для посылки сообщения (сигнала) всякий раз, когда через него продвигается команда:

   1 def push(self, command):
   2     """Send command to the interpreter to be executed.
   3     Because this may be called recursively, we append a new list
   4     onto the commandBuffer list and then append commands into
   5     that. If the passed in command is part of a multi-line
   6     command we keep appending the pieces to the last list in
   7     commandBuffer until we have a complete command. If not, we
   8     delete that last list."""
   9     command = str(command) # In case the command is unicode.
  10     if not self.more:
  11         try: del self.commandBuffer[-1]
  12         except IndexError: pass
  13     if not self.more: self.commandBuffer.append([])
  14     self.commandBuffer[-1].append(command)
  15     source = '\n'.join(self.commandBuffer[-1])
  16     more = self.more = self.runsource(source)
  17     dispatcher.send(signal='Interpreter.push', sender=self,
  18                     command=command, more=more, source=source)
  19     return more

Различные задействованные части модулей crust и filling самостоятельно настраиваются на получение этого сигнала, связываясь с диспетчером в своих конструкторах. Листинг 4.6 содержит полный исходный код элемента SessionListing, размещенного в PyCrust на странице Session:

Листинг 4.6 Код сеансовой страницы PyCrust

   1 class SessionListing(wx.TextCtrl):
   2     """Text control containing all commands for session."""
   3     def __init__(self, parent=None, id=-1):
   4         style = (wx.TE_MULTILINE | wx.TE_READONLY |
   5                  wx.TE_RICH2 | wx.TE_DONTWRAP)
   6         wx.TextCtrl.__init__(self, parent, id, style=style)
   7         dispatcher.connect(receiver=self.push,
   8                            signal='Interpreter.push')
   9     def push(self, command, more):
  10         """Receiver for Interpreter.push signal."""
  11         if command and not more:
  12             self.SetInsertionPointEnd()
  13             start, end = self.GetSelection()
  14             if start != end:
  15                 self.SetSelection(0, 0)
  16             self.AppendText(command + '\n')

Обратите внимание, как получатель SessionListing (его метод push()) игнорирует направленные интерпретатором параметры sender и source. Диспетчер в этом смысле очень гибкий и только посылает принимаемые получателями параметры.

Модуль editor (редактор)

Модуль editor содержит все компоненты редактирования GUI, которые используются в программах PyAlaCarte и PyAlaMode. Если Вам необходимо включить в свою программу редактор исходного кода Python, используйте классы, описанные в таблице 4.6.

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

Таблица 4.6 Классы, определенные в модуле editor

Модуль filling (инспектирование)

Модуль filling содержит все элементы управления GUI, которые позволяют пользователю передвигаться по пространству имен объектов и отображать информацию времени выполнения этих объектов. Четыре определенных в модуле filling класса описаны в таблице 4.7.

Таблица 4.7 Классы, определенные в модуле filling

Использование этих классов в Вашей программе позволит легко создать иерархическое дерево пространства имен Python. Оно может быть использовано в качестве быстрого обозревателя данных, если Вы настраиваете эти данные, как объекты Python.

Модуль interpreter (интерпретатор)

Определенный в классе Interpreter модуль interpreter основан на классе InteractiveInterpreter модуля code из стандартной библиотеки Python. Кроме передачи исходного кода в Python, класс Interpreter также отвечает за обеспечение списков автозавершения, информации подсказок о вызове и даже за обработку кодов клавиш, инициирующих автозавершение (обычно это код клавиши точки ".").

Из-за такого явного разделения ответственности, Вы можете создать собственный подкласс интерпретатора и передать его экземпляр в оболочку PyCrust, а не в стандартный интерпретатор. Это сделано в нескольких программах, для поддержки пользовательских языковых изменений и получения преимуществ среды PyCrust. Например, одна программа подобного типа позволяет управлять лабораторным оборудованием из встроенной оболочки PyCrust. Эта программа использует ведущий слэш (/), чтобы инициировать автозавершение всякий раз, когда после ссылки на одну из частей оборудования появляется ведущий слэш. Появляющаяся опция автозавершения характеризует эту часть оборудования, как оно настроено и в каком текущем состоянии находится.

Модуль introspect

Модуль introspect используется классами Interpreter и FillingTree. Он обеспечивает ряд функций поддержки интроспективного типа для подсказок о вызове и команд автозавершения. Далее показано использование wx.py.introspect для получения всех названий атрибутов объекта списка, исключая атрибуты с ведущими двойными подчеркиваниями:

   1 >>> import wx
   2 >>> L = [1, 2, 3]
   3 >>> wx.py.introspect.getAttributeNames(L, includeDouble=False)
   4 ['append', 'count', 'extend', 'index', 'insert', 'pop',
   5 'remove', 'reverse', 'sort']
   6 >>>

Функция !getAttributeNames() используется классом FillingTree для инспектирования иерархии пространства имен. Один из лучших способов понять модуль introspect состоит в том, чтобы взглянуть на тесты устройства, которые он успешно проходит. Просмотрите файл test_introspect.py в директории установки Python Lib/site-packages/wx/py/tests.

Модуль shell

Модуль shell содержит GUI элементы, которые определяют интерфейс оболочки Python внутри программ PyCrust, PyShell и PyAlaMode. Таблица 4.8 приводит описание каждого элемента. Основным классом является ShellFrame, подклассом - frame.Frame. Он содержит экземпляр класса Shell, выполняющий основной объем работы по обеспечению диалоговой среды Python.

Таблица 4.8 Классы, определенные в модуле shell

Класс ShellFacade был создан при разработке оболочки PyCrust для упрощения доступа из нее к объекту оболочки. Когда Вы запускаете PyCrust или PyShell, экземпляр класса Shell становится доступным в оболочке Python. Например, следующим образом Вы можете вызвать в приглашении оболочки метод оболочки about():

   1 >>> shell.about()
   2 Author: "Patrick K. O'Brien <pobrien@orbtech.com>"
   3 Py Version: 0.9.4
   4 Py Shell Revision: 1.7
   5 Py Interpreter Revision: 1.5
   6 Python Version: 2.3.3
   7 wxPython Version: 2.4.1.0p7
   8 Platform: linux2
   9 >>>

Поскольку оболочка Shell наследует StyledTextCtrl, она содержит свыше 600 атрибутов. Большинство атрибутов используются в приглашении оболочки, так что ShellFacade был создан, чтобы ограничивать количество атрибутов, появляющихся в списке автозавершения при вводе на запрос оболочки. Теперь объект оболочки отображает только около 25 наиболее полезных атрибутов оболочки. Если Вы хотите использовать некоторый атрибут, который не включен в список автозавершения, можете его ввести, и он будет направлен обычной оболочке, сохраненной в качестве атрибута внешнего вида.

Как использовать модули пакета Py в wxPython-программах?

Что делать, если в Вашем приложении Вам не нужен целый фрейм PyCrust? Что, если Вам просто нужен интерфейс оболочки в одном фрейме, и возможно вьювер пространства имён в другом? И что, если Вы хотите, чтобы они были постоянными дополнениями Вашей программы? Такие альтернативы не только возможны, они также довольно легко достигаются. Мы закончим эту главу примером того, как это может быть сделано. Мы вновь вернемся к созданной нами в главе 2 программе, которая имела строку меню, панель инструментов и строку состояния. Мы добавим другое меню с одним пунктом для отображения фрейма оболочки и другим пунктом для отображения фрейма инспектора объектов (filling frame). И, наконец, мы установим корень дерева объектов на объект фрейма из нашей основной программы. Результат показан на рисунке 4.11.

Рисунок 4.11 Базовая программа с фреймами оболочки и инспектирования

Листинг 4.7 показывает модифицированный исходный код (Для объяснения первоначальной программы обратитесь к главе 2). Как видите, чтобы добавить возможность запускать фрейм оболочки и фрейм инспектора объектов с каждым функционирующим фреймом основного приложения, использована всего пара дополнительных строк кода.

Листинг 4.7 Базовая программа с дополнительными работающими инструментами

   1 #!/usr/bin/env python
   2 import wx                                              
   3 from wx.py.shell import ShellFrame                                  (1) Импортирование фреймовых классов
   4 from wx.py.filling import FillingFrame
   5 import images
   6 class ToolbarFrame(wx.Frame):
   7     def __init__(self, parent, id):
   8         wx.Frame.__init__(self, parent, id, 'Toolbars',
   9             size=(300, 200))
  10         panel = wx.Panel(self, -1)
  11         panel.SetBackgroundColour('White')
  12         statusBar = self.CreateStatusBar()
  13         toolbar = self.CreateToolBar()
  14         toolbar.AddSimpleTool(wx.NewId(), images.getNewBitmap(),
  15             "New", "Long help for 'New'")
  16         toolbar.Realize()
  17         menuBar = wx.MenuBar()
  18         menu1 = wx.Menu()
  19         menuBar.Append(menu1, "&File")
  20         menu2 = wx.Menu()
  21         menu2.Append(wx.NewId(), "&Copy", "Copy in status bar")
  22         menu2.Append(wx.NewId(), "C&ut", "")
  23         menu2.Append(wx.NewId(), "Paste", "")
  24         menu2.AppendSeparator()
  25         menu2.Append(wx.NewId(), "&Options...", "Display Options")
  26         menuBar.Append(menu2, "&Edit")
  27                                           
  28         menu3 = wx.Menu()                                                               
  29         shell = menu3.Append(-1, "&wxPython shell",                 (2) Создание меню Debug и его элементов
  30                              "Open wxPython shell frame")
  31         filling = menu3.Append(-1, "&Namespace viewer",
  32                                "Open namespace viewer frame")
  33         menuBar.Append(menu3, "&Debug")
  34         self.Bind(wx.EVT_MENU, self.OnShell, shell)                 (3) Установка обработчиков событий меню
  35         self.Bind(wx.EVT_MENU, self.OnFilling, filling)
  36                                                                  
  37         self.SetMenuBar(menuBar)
  38                                                                  
  39                                                                  
  40     def OnCloseMe(self, event):                                                            
  41         self.Close(True)
  42 
  43     def OnCloseWindow(self, event):                                  
  44         self.Destroy()
  45                                                            
  46     def OnShell(self, event):                                       (4) Обработчик пункта меню OnShell                                                
  47         frame = ShellFrame(parent=self)
  48         frame.Show()
  49                                                      
  50     def OnFilling(self, event):                                     (5) Обработчик пункта меню OnFilling                                           
  51         frame = FillingFrame(parent=self)                                             
  52         frame.Show()
  53 
  54 if __name__ == '__main__':
  55     app = wx.PySimpleApp()
  56     app.frame = ToolbarFrame(parent=None, id=-1)
  57     app.frame.Show()
  58     app.MainLoop()

(1) Здесь мы импортируем классы ShellFrame и FillingFrame.

(2) Мы добавляем пункты в наше третье меню Debug (Отладка) так же, как и в предыдущих двух меню и добавляем его в строку меню фрейма.

(3) Связывание функции с wx.EVT_MENU() позволяет нам ассоциировать с пунктом меню обработчик, вызываемый при выборе этого пункта меню.

(4) Когда пользователь выбирает оболочку Python в меню Debug, создается фрейм оболочки, наследуемый от фрейма панели инструментов (toolbar). Когда фрейм инструментальной панели закрывается, также закрываются любые открытые фреймы оболочки и инспектора объектов.

Резюме

• Пакеты разработчика подобные wxPython по своей природе очень велики и сложны. Взаимодействие между GUI-элементами не всегда интуитивно, ход этого процесса определен событиями и ответами на события, а не линейной последовательностью выполнения. Использование инструментальных средств подобных оболочке PyCrust может существенно повысить Ваше понимание этой событийно-управляемой среды.

• PyCrust - просто другая оболочка Python, подобная оболочкам, включенным в IDLE, Boa Constructor, PythonWin и другие инструментальные средства разработки. Тем не менее, PyCrust был создан с помощью wxPython, применение которого оправдывается, когда Вы разрабатываете программы на wxPython. В частности, у Вас не будет проблем с конфликтами событийных циклов, и Вы сможете манипулировать всеми аспектами Вашей программы при ее выполнении в рамках оболочки PyCrust и обозревателя пространства имен.

• Поскольку PyCrust - часть дистрибутива wxPython, он устанавливается вместе с wxPython, включая весь исходный код. Это облегчает использование PyCrust, нивелируя трудности изучения и обеспечивая интроспективную функциональность Ваших программ.

• Кроме того, модульный проект пакета Py облегчает выбор необходимых для Вашей программы модулей, например, для редактирования исходных текстов, просмотра пространства имен или для обеспечения функциональности оболочки.

• PyCrust помогает Вам контролировать ключевые моменты поведения Вашей программы при ее выполнении. В следующей главе мы используем накопленные знания о wxPython, а также получим некоторую практическую помощь в том, как структурировать Ваши GUI-программы и при этом не запутаться.

Перевод: Савицкий Юрий