Кратки афоризми в уведомителни балончета

Така в предния урок ви показах как да си направите браузър, самият урок беше трудно да бъде предаден в по-разбираем вид. Ако сте го разбрали – добре, ако не съжалявам. За онези, които не са го разбрали или е все още сложно за тях реших да добавя днешния малко хумористичен урок на тема pynotify. Като крайния резултат ще бъде информативно балонче, което ще се стартира през определен период от време (или при стартирането на компютъра) и ще изважда афоризъм за жените от sqlite база данни. От сега искам да кажа, че самият скрипт като цяло е изключително лесен, но за начинаещите в Python може да им бъде полезен, представяйки им някои полезни и доста лесни функции за работа с бази данни и хващане на грешки.

Преди да започнем с урока искам да се извиня на всички жени, които попаднат на статията – афоризмите не са измислени от мен, но просто бяха най-удобния текст, с който можех да си поиграя за настоящия скрипт.

Какво ще ни бъде необходимо

Както и в предните уроци ще посъветвам да избегнете използването на IDE (Integrated Development Environment) – причината: Ако не напишете нещо грешно, няма как да го научите. Средите за разработка ви помагат едва след като сте усвоили самият език и ви трябва нещо по-мощно за работа, но ако сте твърдо решени да ползвате такава среда – не е проблем. Предварително трява да се уверите, че имате инсталирани следните библиотеки за Python:

• python-pysqlite2
• python-notify
• sqlite3

За да бъде примера по-близък до реалността няма да добавям в урока .db файла с базата данни, а само препратка към списъка с афоризмите. Първата ни стъпка ще бъде този списък да го превърнем в база данни и след това ще я използваме в нашият скрипт.

Списъкът можете да намерите на следния адрес: http://is.gd/c839M (използвайте опцията “Виж” и копирайте текста в нов файл, тъй като функцията за изтегляне все още не работи)

От текстов файл към база данни

Приемайки, че вече сте инсталирали всичко необходимо и имате файл thewomen, в който се съдържат афоризмите, идва моментът с прехвърлянето на тези записи в една база данни. Принципно бихме могли за този пример да използваме и самия файл, но това би било прекалено лесно, пък и какво по-хубаво от това да разберете малко за sqlite. Нека преди да напишем скрипта, който ще прехвърли всичко от текстовия файл в .db файла да структурираме стъпка по стъпка това, което трябва да се случи:

1. Тъй като това е проста информация и не се нуждаем от кой знае каква функционалност базата ни данни ще съдържа две колони: id и womenfact
2. id реално ще отговаря на реда в текстовия файл, womenfact на текста
3. За да прехвърлим информацията е необходимо да прочетем файла ред по ред и всеки ред да бъде записан под следващото ID в базата данни
4. id-то ще използваме по-късно, за да изкарваме произволен ред.

Нека пристъпим към самият скрипт. Аз ще го запиша първо целия и след това ще обясня ред по ред какво се случва:

#!/usr/bin/env python
 
import codecs
from pysqlite2 import dbapi2 as sqlite
 
def main():
    file = open('newtexts', 'r')
    try:
        conn = sqlite.connect('thewomen.db')
        c = conn.cursor()
    except:
        print "*** Problem creating the db file"
    try:
        c.execute("""CREATE TABLE women (id INTEGER PRIMARY KEY, womenfact TEXT)""")
        conn.commit()
    except:
        print "*** Problem creatint the table"
    for line in file:
        try:
            c.execute("""INSERT INTO women(womenfact) VALUES('%s')""" % (line.decode('utf-8')))
            conn.commit()
        except:
            "*** Can't write to the database"
    file.close()
    c.close()
 
if __name__ == '__main__':
    main()

Нека обясним сега какво сме направили.

В първите два реда вмъкваме необходимите библиотеки, които ще използва скрипта. След което дефинираме нашият главен метод main(). Започваме нашият метод с отварянето на файла thewomen в режим на четене (за това служи параметъра ‘r‘). След което опитваме да се свържем към базата данни thewomen.db. С except прихващаме възможни грешки, които евентуално биха възникнали при създаването на .db файла. После поставяме курсор “c“, и в следващият опит създаваме нашата таблица с две колони id и womenfact. Първата колона трябва да бъде Integer (т.е. число) и ще бъде наш главен ключ – това е достатъчно за sqlite да разбере, че тази стойност ще трябва сама да увеличава стойността си (за разлика от MySQL, където това трябва да опоменем изрично). Колоната womenfact ще съдържа текст (запознатите с MySQL може да потърсят VARCHAR, но в sqlite няма такъв тип данни[http://www.sqlite.org/datatype3.html]). Чрез conn.commit() казваме на sqlite да приложи нанесените от нас промени, т.е. да бъдат записани във файла. Това, което остава за нас е за всеки ред да извъшиме нов запис в базата данни, като важното в случая е да запомните, че ние ще ще декодираме информацията в utf-8, за да нямаме проблеми по-късно с родния ни език. При всеки запис ще потвърждаваме промените с conn.commit(). След като приключи цикъла, т.е. обходили сме всичките 130 реда от нашия файл, затваряме файла, който сме чели и затваряме връзката към базата данни.

Изпълнението на самият скрипт отнема около 5 секунди след което можете да прегледате съдържанието на базата данни с sqliteman.

Да се научим и да четем

В нашият случай първо се научихме да пишем, а след това да четем, но това е основният път към научаването в нашият случай. Ако незнаехме как да пишем – нямаше да има какво да четем нали така? Нека погледнем какво ще трябва да се случая в нашият четец:

1. Трябва да осъществим връзка с базата данни
2. Трябва да си генерираме произволно число между 0 и 130 (все пак не искаме всеки път да виждаме едно и също)
3. Ще поискаме ред от базата данни с номер произволното число, което сме генерирали
4. Резултата ще го разкодираме в utf-8 и ще го покажем чрез Notify балон.

Ето го и готовият скрипт:

#!/usr/bin/env python
from pysqlite2 import dbapi2 as sqlite
import codecs
import random
# това го забравих, но ще ни е необходимо ако не искаме
# всеки път да пишем директния път до базата данни
import os
try:
    import pynotify
except:
    "*** You don't have pynotify installed!"
 
def main():
 
    try:
        # Използваме os.environ['HOME'] за да вземем пътя до личната директория
        # на потребителя, все пак скрипта ни ще бъде стартиран като обикновен потребител
        # ако го стартираме като root, то ще трябва да запишем базата данни в
        # директорията на root: /root/.config/
        conn = sqlite.connect('%s/.config/thewomen.db' % os.environ['HOME'])
    except:
        print "*** Error connecting to the db file"
    c = conn.cursor()
    number = random.randint(1, 130)
    try:
        c.execute("""SELECT womenfact FROM women WHERE id = %i""" % number)
    except:
        print "*** Problem selecting a row from the db file"
    row = c.fetchone()
    pynotify.init("womenfacts")
    n = pynotify.Notification("Womenfact:", "%s" % row[0].encode('utf-8'), "dialog-information")
    n.show()
    c.close()
 
if __name__ == '__main__':
    main()

И така първите два реда с import са ви познати и от първия скрипт. С реда import random добавяме библиотеката за генериране на произволни числа. За библиотеката pynotify използваме опит, защото в случай, че потребителя няма инсталиран pynotify той трябва да знае за това, за да може да го инсталира. Ако предоставяте приложението си като .deb пакет примерно тази част можете и да я пропуснете, тъй като най-вероятно ще сте добавили python-pynotify в зависимостите на пакета. В main() метода свързването с базата данни е абсолютно същото, както и при създаването на базата данни – в случая нищо ново под слънцето. Променливата number използваме, за да запишем в нея произволно число използвайки метода randint (произволен integer), който приема като параметри диапазона, в който трябва да бъде числото, тъй като ние имаме 130 записа в нашата база данни, то диапазона ще бъде между 1 и 130. След което извикваме нашият курсор, като му казваме да избере womenfact от таблицата women, където id е равно на генерираното от нас число. Забележете, че при SQLITE сравненията не се правят с двойно равенство, както в Python. Нещо, което изпуснах да отбележа също е и, че при execute използваме тройни кавички – причината е, че в подобни заявки, може да ни се наложи да използваме двойни и единички кавички и е добра практика да използвате тройни, за всеки случай. Задаваме променлива row (ред), към която присвояваме първият резултат от нашата заявка. Имайте предвид, че резултата е масив – конкретно в нашият случай е с една единствена стойност, но все пак остава масив и ще трябва по-късно да го третираме като такъв. С реда pynotify.init("womenfacts") инициализираме pynotify, като му казваме, че ние сме ново приложение, което иска да използва услугата за уведомявания. Ако изпуснете този ред, най-вероятно няма да видите никакво балонче ;). Променливата n става нашето уведомление “Notification”, което приема три параметръра:

1. Заглавие – “Womenfact:”
2. Текст, който е първият елемент от масива, кодиран в utf-8
3. Име на изображение, което да бъде използвано – dialog-information

Казваме на нашето уведомление да бъде показано с метода show() и прекъсваме връзката с базата данни.

Да направим използването на системата забавно

След като вече имаме нашият скрипт, който от своята база данни извежда произволен афоризъм може да се каже, че сме почти готови. Това което остава е да свъжеме скрипта ни със системата, така че да се показва автоматично. За целта имам три възможности:

1. Да прикачим скрипта към глобална клавишна комбинация (виж Python: Актуалната песен в Clipboard)
2. Да добавим скрипта към автоматично стартиращите се приложения (можете да го направите от Startup Applications)
3. Последния и по-забавен разбира се е да накараме нашият скрипт да се стартира през определен период от време. За тази цел обаче ще трябва да използваме cron (услуга в UNIX/Linux света за автоматизиране на процеси)

Тъй като първите два варианта по обясними причини не са толкова интересни, в този урок ще обясня само последния. Преди да добавим нашият скрипт към списъка на cron е редно да направим няколко корекции.

• -Ще прекръстим скрипта си на нещо по-кратко и ще махнем разширението му – нека бъде womenfacts и ще го направим изпълнум

mv името_на_вашия_скрипт.py womenfacts && chmod +x womenfacts

• Ще преместим нашата база данни на място, от което няма да я забършем по погрешка (~/.config)

mv thewomen.db ~/.config/

• Трябва да нанесем промяната в нашият скрипт, за да нямаме проблеми с връзката към базата данни

Променяме:

conn = sqlite.connect('women.db')

на:

conn = sqlite.connect('%s/.config/women.db' % os.environ['HOME']) # Използваме os.environ['HOME'], за да вземем пътя до домашната директория на потребителя!

Наложително е да използваме абсолютния път до директорията – в случая ~/ няма да ни бъде от голяма полза.

• Копираме скрипта ни в /usr/local/bin (за да бъде глобално изпълним):

sudo cp -fp womenfacts /usr/local/bin/ # използваме и параметъра -p, за да запазим правата върху файла

Тествайте, за да се уверите, че при изпълнението на womenfacts от терминала виждате балончето.

Сега идва реда на cron. Ако до сега не сте използвали cron. Първото нещо, което трябва да направите е да стартирате crontab с параметъра -e, в което ще бъдете попитани кой редактор искате да използвате (none, pino, vi, joe и т.н.). Имайте предвид, че ако искате cron да бъде запазен за всяка сесия, а не само за настоящата ще трябва да стартирате corntab като root (с администраторски права). По подрабиране, най-вероятно cron ще бъде празен. За нашия скрипт ние ще трябва да въведем следното:

*/5 * * * * DISPLAY=:0 PYTHONPATH=::/usr/lib/python2.6/dist-packages/gtk-2.0/:$PYTHONPATH /usr/bin/python /usr/local/bin/womenfacts # JOB_ID_1

Какво означава това. Първата част */5 означава да бъде стартиран всеки пет минути. Ако е само 5 означава в петата минута на всеки час. Останалите параметри са за съответно: час, ден от месеца, месец, ден от седмицата (общо пет с първия параметър). Тъй като нашият пример е малко по-специфичен – налага се да работиме с графично приложение задаваме някои константи преди да изпълниме нашият скрипт чрез cron. Първата и най-важна е DISPLAY=:0 означва, че ще използваме първия дисплей, останалите са свързани с пътищата да Python и използваната библиотека GTK и накрая пътят до нашият скрипт. За повече информация как да боравите с cron и как да разберете видовете настройки можете да прегледате информацията в wikipedia [http://en.wikipedia.org/wiki/Cron] или прегледайте man страницата. За по-бързо разяснение:

.---------------- минута (0 - 59)
|  .------------- час (0 - 23)
|  |  .---------- ден от месеца (1 - 31)
|  |  |  .------- месец (1 - 12) ИЛИ jan,feb,mar,apr ...
|  |  |  |  .---- ден от седмицата (0 - 7) (Неделя=0 или 7)  ИЛИ sun,mon,tue,wed,thu,fri,sat
|  |  |  |  |
*  *  *  *  *  команда, която да бъде изпълнена

PyBrowser - уеб-браузър само в по-малко от 100 реда код

Преглеждайки днес новостите по мрежата в любимия ми сайт TuxRadar попаднах на един нов видео урок, който за 20 минути ни показва как можем да използваме Python, Webkit и PyGTK, за да си направим просто браузър. За съжаление урока не беше пълен и всичкото ставаше от Python интерпретатора, затова реших да използвам видео урока за база и, доколкото е възможно да го разширя до нещо функциониращо. В този урок – ще ви покажа как да създадете от-до браузъра и съответно как да добавите, някои полезни функции. В края на урока ще добавя и препратки, в които можете да търсите повече информация за използването на webkit ако решите да разширите браузъра с повече възможности.

Нека започнем

Какво ще ни бъде необходимо. Първо трябва да се уверите дали имате инсталирано всичко необходимо:

• python
• python-gtk2
• python-webkit

Разбира се, за да пишете код ще ви е необходим и редактор – тук всичко остава във ваши ръце. Ще препоръчам само да не използвате среда за разработка като Eclipse или NetBeans, тъй като за начало е напълно излишно, тъй като ще бъде редактиран само един файл (функционален браузър в един файл – точно така). Разбира се можете да подготвите и три икони – една за прозореца, една за бутон Go и една за презареждане. Може и без тях, но аз не обичам да ползвам бутони с текст. В самия урок, ще добавя коментар, как можете да използвате и нормални бутони с текст или бутоните, включени в GNOME (което ще ви позволи и превод на интерфейса директно с писането на приложението).

Вмъкване на всичко необходимо и първия прозорец

Нека започнем с писането. Първоначално е редно да добавим библиотеките, които ще използваме и да създадем скелета на приложението (класовете и методите). Започваме от вмъкването на необходимите библиотеки със следните 4 реда:

import gtk
# Следващите два реда са необходими, за да не получавате грешка от Glibc при стартирането на приложението
import gobject
gobject.threads_init()
# И разбира се добавяме webkit
import webkit
 
class PyBrowser:
    def __init__(self):
        pass
 
    def main(self):
        # тук стартираме основния метод на gtk
        gtk.main()
 
    def delete_event(self, widget, data=None):
        # тук ще дефинираме изхода от приложението, за което отново използваме метод от gtk
        gtk.main_quit()
 
    def enter_pressed(self, entry):
        # оставяме място за действие при натискате на клавиша Enter в полето за писане
 
    def go_clicked(self, btn):
        # оставяме място да дефинираме действието на бутона Go!
 
    def refresh_browser(self, btn):
        # място за действието на бутона за презареждане на страницата
 
    def title_changed(self, webview, frame, title):
        # добре ще е разбира се да обновяваме заглавието на прозореца със заглавието на настоящата
        # страница
 
if __name__ == "__main__":
    # След като използваме класове трябва да ги прехвърлим към обект
    browse = PyBrowser()
    # и с този обект да извикаме основния метод main()
    browse.main()

Както виждате основната част на приложението е изключително интуитивна. Редно е да се поясни, че конструктора __init__ ще ни служи за да построим самия прозорец на приложението и в него ще опишем всички действия, бутони, полета и самия браузър. Ако до момента не сте срещали подобен конструктор прегледайте http://www.penzilla.net/tutorials/python/classes/ – изключително добре описано с примери .Също така self обяснява, че това са лични методи към класът PyBrowser и за да ги извикваме ще трябва да пишем self пред името на всеки метод.

Да създадем прозореца с джаджите

В gtk всяко нещо е widget, включително бутоните, полетата за текст и т.н. И те трябва да бъдат добавяни в съдържатели – било то фиксирани, вертикални кутии, хоризонтални кутии, таблици и т.н. В този урок ние ще използваме вертикални и хоризонтални кутии. Но преди това нека първо създадем нашия прозорец. Това става изключително лесно добавяме следното в __init__:

        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.connect("delete_event", self.delete_event)
        self.window.set_title("PyBrowser v.0.1")
        self.window.set_icon_from_file("icons/pybrowser_small.png")
        self.window.resize(600, 480)

Да поясним какво сме направили – с първия ред създаваме нов прозорец, който да бъде първи в йерархията (в случай, че по-късно използваме още прозорци към приложението). Свързваме “delete_event” – с методът, който предварително сме дефинирали. Това е важно, за да кажем на нашето приложение, че при натискане на бутона X в заглавната лента на прозореца искаме приложението да спира да работи. След което с set_title, set_icon_from_file и resize определяме какво да бъде заглавието на нашето приложение, къде се намира иконата на прозореца (директорията icons/ трябва да се намира при файла pybrowser.py) и определяме големината на прозореца по подразбиране 600×480 пиксела.

Време е да дефинираме и нашите съдържатели – ще използваме три: HBox, VBox и ScrolledWindow. Последният ще съдържа нашият браузър, за да можем при отварянето на страници, по-големи от нашият прозорец да използваме плъзгачи за скрол. С други думи добавяме следното:

        # контейнерът за webkit
        self.scroller = gtk.ScrolledWindow()
        # hbox и vbox сътоветно за хоризонтална и вертикална подредба
        self.vbox = gtk.VBox()
        self.hbox = gtk.HBox()

Няма никакво значение как ще ги подредите, тъй като самото им използване ще се случи малко по-надолу в кода. HBox ще използваме за текстовото поле, в което ще въвеждаме URL, бутонът за старт на зареждането и бутонът за презареждане. Остава да ги дефинираме и да ги добавим към съдържателя:
Първо да създадем нашето текстово поле:

        # Дефинираме нашето поле с името urltext
        self.urltext = gtk.Entry()
        # Задаваме на полето текст по подразбиране - не е задължително
        # но пък от друга страна е по-добре от празна кутия
        self.urltext.set_text("http://")
        # задаваме размер по подразбиране - първата стойност ще бъде пропусната по подразбиране
        # докато втората, ще се използва за задаване на височината, тъй като бутоните, които аз
        # използвам са с рамери 32x32. В случай, че използвате други размери, можете спокойно
        # да изтриете този ред
        self.urltext.set_size_request(600,38)
        # Свързваме действие, когато потребителя въведе адрес и натисне клавиша Enter
        # нещо, което повечето хора правят дори несъзнателно
        self.urltext.connect("activate", self.enter_pressed)

След като имаме полето за текст остава да създадем и двата бутона:

        # Създаваме нов бутон с името gobutton
        # В случай, че решите да не използвате изображение, можете да изтриете
        # следните 3 реда и да промените този на:
        #self.gobutton = gtk.Button("Go!")
        self.gobutton = gtk.Button()
        # Дефинираме обект за изображение goimage, в който ще запишем
        # изображението, което ще използваме за този бутон
        self.goimage = gtk.Image()
        # задаваме пътят към изображението
        self.goimage.set_from_file("icons/go.png")
        # прикачаме изображението към бутона
        self.gobutton.set_image(self.goimage)
        # Ако сте решили да не използвате изображения, тук трябва да спрете с триенето
        # Задаваме действие не бутона, когато той бъде натиснат искаме да се изпълни
        # методът go_clicked
        self.gobutton.connect("clicked", self.go_clicked) # the Go! button
 
        # Правим същото за бутонът за презареждане
        self.refresh = gtk.Button()
        self.refreshimage = gtk.Image()
        self.refreshimage.set_from_file("icons/reload.png")
        self.refresh.set_image(self.refreshimage)
        self.refresh.connect("clicked", self.refresh_browser) # The reload button
 
        # След като сме създали текстовото поле и бутоните трябва
        # да ги добавим към хоризонталния съдържател HBox
        self.hbox.pack_start(self.urltext)
        # Забележете вторият параметър False, той казва на Gtk
        # Че тези бутони трябва да използват минималното място,
        # от което се нуждаят за да бъдат показани
        self.hbox.pack_start(self.gobutton, False)
        self.hbox.pack_start(self.refresh, False)

Нека създадем и нашият браузър:

        # Дефинираме браузъра си като WebView - рамка за визуализиране
        # на HTML страници
        self.browser = webkit.WebView()
        # Просто защото е забавно задаваме още тук браузърът да отвори google
        # По този начин си имаме първоначална страница за зареждане
        # Ако искате да използвате файл, можете да добавите следното, като
        # предварително добавите import os при вмъкването на библиотеките:
        # self.browser.open("file://%s/file.html" % (os.getcwd()))
        self.browser.open("http://www.google.com/webhp?hl=en")
        # Използваме слушател, който да стартира метода title_changed, щом
        # заглавието на страницата бъде променено
        self.browser.connect("title-changed", self.title_changed)
        # Създаваме сигнал, който ще контролира нашата лента за зареждане
        # по този начин "слушаме" за промени
        self.browser.connect("load-progress-changed", self.load_progress_changed)
        # дефинираме какво трябва да се случи при започване на зареждане
        self.browser.connect("load-started", self.load_started)
        # дефинираме и какво трябва да се случи, когато страницата е заредена
        # тези методи ще създадем след малко
        self.browser.connect("load-finished", self.load_finished)
        # Добавяме, както споменахме по-рано браузърът в ScrolledWindow съдържател
        # така можем да използваме плъзгачи, в случай, че страницата е по-голяма
        # от нашия прозорец
        self.scroller.add(self.browser)

В следващата част от нашият код, ще извършим няколко неща наведнъж, а именно:
1. Ще създадем нашата лента за прогрес

        self.progress = gtk.ProgressBar()

2. Ще добавиме всичките до сега дефинирани джаджи във вертикалния съдържател, като не трябва да забравяте, че този тип съдържатели, могат да съдържат и други съдържатели:

        # Първо добавяме нашата хоризонтална кутия, с текстовото поле
        # и бутоните. Помните вторият параметър (Flase), оказва съответната
        # джаджа да не се разпростира много, а да използва от прозореца
        # само толкова, колкото й трябва
        self.vbox.pack_start(self.hbox, False)
        # Под бутоните и текстовото поле бихме искали директно да виждаме
        # нашият браузър
        self.vbox.pack_start(self.scroller)
        # И накрая добавяме лентата за прогрес, която по-късно ще скрием
        self.vbox.pack_start(self.progress, False)

3. Последното, което остана при дефинирането на нашия прозорец е той да съдържа дефинираните до сега съдържатели и да бъде показан. Това правим по следния начин:

        # Vbox вече съдържа всичките джаджи, които сме дефинирали
        self.window.add(self.vbox)
        # Казваме на нашият прозорец да покаже всичко, което сме му добавили,
        # включително и себе си
        self.window.show_all() # Just show everything

Малко действия

До тук това, което постигнахме е просто един прозорец, който в идеалния случай ще се зареди, но няма да бъде функционален, тъй като бутоните, и самите действия все още не са дефинирани. Прегледайте отново скелета на приложението. Ще разгледаме методите един по един. Като накрая ще добавим методите, който ще контролират нашата лента за прогрес (не мога да измисля по-точен превод на български, така че моля уважаемият читател да ме извини).

Натискането на клавишът [Enter]:

def enter_pressed(self, entry):
        self.browser.open(self.urltext.get_text())

Методът приема два параметъра – първо, че е част от класа, второто, че сигналът му е пратен от Entry – текстово поле. Това което казваме да се случи: нека браузърът (self.browser) отвори (open) съдържанието на текстовото поле. self.urltext – е нашето текстово поле и то има метод get_text(), който взима неговото съдържание. В Този метод можете да добавите и проверка, дали въведения адрес е валиден или пък ако искате при невалиден адрес, да отворите google търсачката. За целта нека ви покажа как можете да го направите по по-елементарния начин (без регулярни изрази):

def enter_pressed(self, entry):
    # съдържанието на текстово поле го записваме в променлива
    theurl = self.urltext.get_text()
    # и започваме да проверяваме:
    if "http://" in theurl or "www." in theurl:
        self.browser.open(theurl)
    else:
        # Ако няма http или www в адреса, допускаме, че това е
        # просто някакъв текст, за да го превърнем в текст, който
        # да добавим към адреса на google за търсене заменяме празните
        # полета със знака +
        searchterm = theurl.replace(" ", "+")
        # предаваме нов адрес, в който е и нашето понятие за търсене
        self.browser.open("http://www.google.com/search?sourceid=chrome&ie=UTF-8&q=%s" % searchterm)

Идентичен е и метода при натискането на бутона Go!. Разликата е в това, че сигналът се изпраща от бутон:

def go_clicked(self, btn):
    self.browser.open(self.urltext.get_text())

По същия начин описан по-горе, можете да си добавите и проверка. Би било добре тази проверка да я направите с регулярен израз, защото ще е по-смислено и по-практично.

Методът за нашият бутон за презареждане ще изглежда по следния начин:

def refresh_browser(self, btn):
    # За наше успокоение WebView от WebKit има тази функция вградена
    # и това, което трябва да направим е просто да я извикаме
    self.browser.reload()

Разбрахме се още в началото, че нашият браузър ще показва заглавието на настоящата страница – затова и добавихме сигнал при дефинирането на нашият браузър, това, което остава за нас е да кажем какво трябва да се случи.

def title_changed(self, webview, frame, title):
     # Тук това вече е част от нашият Gtk прозорец, затова и не извикваме
     # webkit на помощ, от него просто взимаме заглавието
    self.window.set_title(title)

Малкото, което остана е да дефинираме и три метода за нашата прогресна лента. Единият от тях трябва да разделя зареждането на стъпки. Другите два служат просто за прихващане на сигналите – “започване на зареждането” и “приключване на зареждането”. WebKit ни улеснява изключително много и в трите метода. Като ни предлага всичко готово. Това, което се изисква от нас е да определим как ще бъдат разделени стъпките, за да ги разбере GTK и какво трявбад а се случва при започване на зареждане и когато страницата бъде заредена.

    def load_progress_changed(self, webview, amount):
        # Тук ще обясня какво е amount - това е цялото количество данни, които
        # ще бъдат изтеглени - това ни се подава от WebKit. За да работи
        # Нашата прогресна лента - трябва големината на данните, да разделим на 100.0
        # Нарочно не използваме integer - остава да подадем резултата на метода
        # set_fraction, който е част от gtk.ProgressBar
        self.progress.set_fraction(amount / 100.0)
 
    def load_started(self, webview, frame):
        # За да бъде по-интерактивен браузъра показваме
        # лентата за зарежда само, когато има зареждане
        self.progress.show()
 
    def load_finished(self, webview, frame):
        # Щом зареждането приключи взимаме адреса на заредената
        # страница и го записваме в текстовото поле за адрес
        # след което скриваме лентата за зареждане, за да не ни пречи
        self.urltext.set_text(frame.get_uri())
        self.progress.hide()

Край

Надявам се с този урок да сте разбрали колко е лесно да направите собствен браузър с Python и WebKit. Това, което можете да приемете като домашно е да разгледате другите методи, и действия, които ви предлага Webkit и просто да ги добавите във вашето приложение. Тъй като за момента не успях да намеря публично API, с python-webkit аз използвах това, което е за C – не се различават по нищо, тъй като ако не знаете, Python почти без проблем използва WebKitWebView С-библиотеките като собствени.

Разбира се можете да изтеглите и крайният резултат в случай, че имате проблем с разбирането на целия текст.
PyBrowse (13.08 KB) 125 изтегляния