Ако някога ви се е случвало да искате да изтеглите песен от grooveshark и не сте имали тази възможност може би с това приложение ще мога да ви помогна. gSharkDown е десктоп клиент за grooveshark повече ориентиран към прослушване не песните, но включващ и възможност за изтеглянето им и някои други полезни функции. Като цяло клиентът беше предвиден за лично ползване, но след версия 0.2.2 сметнах, че мога да го споделя и с други.

Приложението е написано на Python и използва pyGTK за графичен интерфейс и GStreamer за просвирване на песните директно от grooveshark без да бъдат изтегляни. Библиотеката, която се използва за търсене и изтегляне на песните е предоставена от проекта groove-dl (друго wxPython приложение само за изтегляне на песни).
С какво gSharkDown е по-различен

• Търсене за песни в grooveshark с възможност за подсказване (запаметява търсенията и при следващото ползване ги предлага)
• Списък за просвирване, който можете да заредите с песни от резултатите от търсенето
• Вграден плейър, с все още не напълно функционираща опция за непрекъснато свирене (повторение на списъка), но очаквам скоро да коригирам проблема
• Информационен диалог за подробности относно дадена песен от списъка с резултати
• Бутон за изтегляне (изтегляне на песни една по една)
• Удобна статус икона в GNOME панела

Изтегляне и инсталиране на gSharkDown

Ако използвате Ubuntu или Debian базирана дистрибуция с GNOME можете да инсталирате gSharkDown с предоставения .deb пакет. Последната версия: gsharkdown_0.2.2_all.deb. За други дистрибуции ще трябва да изтеглите програмата от mercurial хранилището и да я инсталирате ръчно:

$ hg clone https://bitbucket.org/vkolev/gsharkdown
$ sudo cp -rfp gsharkdown /opt/
$ sudo echo '#!/bin/bash' >> /usr/local/bin/gsharkdown
$ sudo echo 'cd /opt/gsharkdown/ && python gsharkdown.py' >> /usr/local/bin/gsharkdown
$ sudo chmod +x /usr/local/bin/gsharkdown

След което остава да добавите стартер в менюто, което в GNOME можете да направите от System -> Preferences -> Main Menu. Ако искате да следите развитието на приложението, да изтеглите последната версия или имате предложения  към развитието на приложението можете да посетите https://bitbucket.org/vkolev/gsharkdown

След статията относно скриването на файлове в изображения и аудио файлове се роди идеята за графичен интерфейс, който да улесни процеса и да съкрати писането в терминала. От тест на тест се появи и първата версия на pySteg – графичен интерфейс за steghide, който беше вдъхновен от Steghide UI за Windows. Като цяло разликата с Windows приложението е минимална, с идеята да е удобно за хората, които използват и две операционни системи Windows и GNU/Linux. Причината за това е, че pySteg не се предполага, че някога ще има версия за Windows – просто не е предвидена, а и нямам желанието да правя такава. Като за първа версия се постарах все пак да включа повечето функции, които предлага steghide. Приложението е написано на python и използва GTK за графичния интерфейс, което позволява добра интеграция с GNOME десктоп средата.

Особености на pySteg

pySteg предлага tab интерфейс, който е разделен на три основни части:

• Вмъкване (Embeding) – включващо всичките функции за скриване на един файл в друг.
• Извличане (Extracting) – извличането на информация, скрита във файл.
• Терминал (Console) – директен достъп до steghide, както и информация за извършваните задачи

Повечето функции са само обясняващи се и ще ги разберете бързо ако сте чели статията относно stehide.

Недостатъци на pySteg

• pySteg за момента не проверява дали файлът, който сте избрали е достатъчно голям, за да побере информацията, която искате да скриете.
• За момента филтрирането на съдържащите файлове е не гарантира, че тези файлове ще могат да бъдат използвани от steghide. За пример скриването на информация в .mp3 файл не е възможна, но за целта съществува mp3stego, чиято поддръжка е планирана за следваща версия.
• Липсва статус икона, за бързо достъп, добавянето ѝ е предвидено за следващата версия.

Изтегляне

Кодът на pySteg се съхранява в github.com и също от там можете да изтеглите архиви във форматите .zip или tar.gz. В хранилището е и мястото за съобщаване на грешки и проблеми с приложението, както и да предлагате нови функции и разширявания на приложението.

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

Планове

За този момент в списъка с неща, коти трябва да бъдат добавени/оправени стои следното:

• Добавяне на възможност за превод на интерфейса
• Добавяне на статус икона
• Потребителски настройки за приложението и предпочитаните настройки за криптиране

Често пишейки с приятели в Skype, във IRC или публикувайки публикации във форуми ми се налага да добавям изображения за целта вместо да качвам изображенията на мой хост използвам безплатни услуги от други страници. Тази, която най-често ползвам е Imgur.com. За да улесня процеса с качването на изображения и да си спестя регистрацията реших да направя едно малко приложение, което да върши тази работа вместо мен, като същевременно води и лог за качените от мен изображения, така че да мога да ги използвам и по-късно, както и да ги изтривам при необходимост. Така след случайно ровене по директориите на твърдия ми диск открих дизайн на подобно приложение, което бях правил на Glade. Необходима бе малка редакция, след което добавянето на малко код, за да го накарам да работи. Така се роди ImgurUp.

Обновление: Програмата беше обновена до версия 1.1 – добавена е функция за снимане на екрана.
Изтегляне от github.com

Какво прави ImgurUp

Приложението ви предоставя лесен и удобен начин за качване на изображения с услугата на imgur.com. След като изберете изображение, заглавието му бива автоматично генерирано от името на файла – разбира се това можете да промените, но ако бързате е удобен начин просто да имате някакво заглавие, което да ви подсеща какво сте качили. След натискане на бутона Upload изображението бива изпратено към Imgur сайта и ви предоставя списък с връзки към изображението – основните биват същевременно записвани в базата данни на ImgurUp. Самото приложение разполага със статус икона, която стои през цялото време в лентата с активни приложения, което ви позволява да скриете прозореца на приложението и да го извикате при необходимост, за да качите следващото изображение. Лесно и просто.

Добавяне на API ключ

Тъй като ImgurUp се стреми да бъде лесно и просто приложение без излишна функционалност не сметнах за необходимо да добавям методи за идентификация тъй като информацията за изображенията се записва в локална база данни – по този начин се обезсмисля използването на наречения от Imgur.com – “Authenticated API key”, който позволява да използвате своя акаунт от Imgur и в него да се записва информацията за всяко качено изображение. За да добавите ключ, с който да използвате ImgurUp трябва да изпълните следните стъпки:

• Отидете на адрес: http://imgur.com/register/api_anon
• Въведете изискваните от страницата данни след, което ще получите вашият API ключ
• Стартирайте ImgurUp, изберете с десен бутон на статус иконата и изберете опцията API Key
• В появилия се диалог въведете ключа, който сте получили от Imgur.com и изберете опцията Save
• Това е – можете да качвате снимки с ImgurUp.

За потребители

Ако се натъкнете на грешка или искате да предложите разширение на приложението с други възможности можете да направите това с коментар в тази публикация или на адреса за проблеми в github.com: https://github.com/vkolev/ImgurUp/issues

Имайте предвид, че след качване на изображение информацията, която се записва в локалната база данни е следната:

• Връзка до страницата в Imgur.com на съответното изображение, то която можете да получите повече връзки за споделяне на изображението. Отварянето на този адрес става с двойно кликване на съответния ред в прозореца.
• Заглавие на самото изображение, което сте задали при качването му – с цел подсещане какво точно сте качили
• Адрес за изтриване на изображението – можете да го използвате като изберете съответния запис и натиснете бутона Delete – имайте предвид, че по този начин записът веднага ще бъде изтрит от базата данни и ще бъдете пренасочени към страница в Imgur.com, от която ще трябва да потвърдите изтриването.

За разработчици

ImgurUp е лицензиран от MIT лиценз и може да бъде свободно редактиран. Приложението е написано на Python и за графичен интерфейс използва PyGTK. За да се сдобиете с изходния код на ImgurUp просто трябва да изтеглите кода от github.com:

git clone git@github.com:vkolev/ImgurUp.git

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

ImgurUp зависи от следните библиотеки:

• python-gtk2
• python-simplejson
• python-dbus
• python configobj
• python-pysqlite2

Изтегляне

Можете да изтеглите приложението в няколко формата. За потребителите на Ubuntu/Debian е добавен .deb пакет. За останалите дистрибуции ще трябва да използват tar.gz или .zip архив, с който да инсталират приложението ръчно.

.deb пакет

ImgurUp () 66 изтегляния

.tar.gz архив

ImgurUp tar.gz () 63 изтегляния

.zip архив

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

Така в предния урок ви показах как да си направите браузър, самият урок беше трудно да бъде предаден в по-разбираем вид. Ако сте го разбрали – добре, ако не съжалявам. За онези, които не са го разбрали или е все още сложно за тях реших да добавя днешния малко хумористичен урок на тема 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 изтегляния

Колко сигурна е пароалта ви?

Рядко човек се замисля дали паролата, която използва е сигурна. Всъщност масово хората използват пароли, които са лесни за запомняне. От гледна точка на сигурността това винаги е грешно, но е в самото мислене на човека. Доста често срещам хора, които ползват една и съща парола навсякъде, в най-добрия случай използват няколко пароли навсякъде и то с идеята, че са лесни за запомняне и няма да ги забравят. Но колко сигурни са тези пароли? Изобщо би ли се досетил някой за тях. Хората, работещи по това да разбират чужди пароли за добро или лошо са измислили различни методи за разбиването им. Някои от тези методи са свързани с логика, друга част се базират на най-често използваните пароли или на списъци с такива. С тази статия ще се опитам да ви покажа какво трябва да имате предвид при избора на своята парола и какво трябва да избягвате.

Най-честите грешки в избора на парола

Едно от основното правило при избора на парола, което не всички хора следват е използването само на малки букви или пък само на цифри. Много хора мислят, че използвайки за парола рождената си дата са се защитили. Донякъде е така, но в момента почти всеки е регистриран във Facebook – съответно всеки може да провери кога е вашият рожден ден – от там не е трудно да почне да тества пощата ви с различни комбинации. Имена, думи и подобни пароли също не са особено трудни, тъй като се изисква малко мислене и налучкване или сдобиването с wordlist (обикновено текстов файл с огромен брой различни думи и имена), който се използва в комбинация с програма, която да върши тестването автоматично т.нар. BruteForce – програмата праща заявки към формата за име и парола със зададените потенциални пароли от списъка с думи, докато не уцели. В крайна сметка използването на цифри или обикновени за парола е изключително несигурно. Също толкова несигурно, колкото и използването на имена на домашни любимци и подобни.

Тук бих искал да вмъкна и информацията за един инструмент наречен CUPP (Common User Passwords Profiler), който представлява един Python скрипт, който на база информация за даден потребител – рождена дата, две/три имена, прякор, данни за близки и домашни любимци генерира списък с възможни пароли. Всеки използващ този инструмент и поровил се достатъчно в интернет, за да събере информация за вас би могъл да генерира списък, в който е възможно да присъства вашата парола. Всъщност самия инструмент е много полезен и за обикновените потребители, тъй като по този начин могат сами да тестват колко е сигурна паролата им. Но тук винаги трябва да имате предвид, че програмата може да направи грешка, тъй като не е перфектна.

Друга грешка при използването на различни пароли е тяхното записване в каквато и да е форма с цел запомняне. Самото записване на пароли в тефтерчето, което “никой не вижда”, в телефона “който никой няма да прегледа” и т.н. е грешно. Замислете се над това, колко е сигурен вашият телефон? Много хора го смятат за изключително сигурен и неподлежащ на атака, но всъщност е толкова лесно, колкото не можете да си представите. Напълно е възможно някой да се свърже към телефона ви през Bluetooth и да извлече цялата информация от него. Повече информация по въпроса можете да прочетете в следния pdf документ: Bluetooth_Hacking.pdf. Тефтерчето ви винаги може да попадне в чужди ръце дори, когато не подозирате. Опитвайте се да запомните паролите си. Или ако ги записвате – никога не ги записвайте на важен документ и никога не посочвайте, че това е парола – нека бъде просто някакъв текст някъде си, а ако използвате примерите за създаване на по-сигурна парола, не я записвайте със специалните знаци и цифрите – нека не личи, че това е парола.

Как да изберем сигурна парола?

За да изберете сигурна парола имате в общи линии два избора:

• Избор на парола, която по-лесно да запомните
• Генериране на парола, която ще трябва да опитате да запомните

В първия случай трябва да изберете дума или фраза, която да преобразувате в парола. Това е може би най-лесния начин да си изберете сравнително сигурна и лесна за запомняне парола. Как обаче да го направите? Намислете си фраза, която често използвате или която харесвате. И я пренапишете, заменяйки буквите с цифри, големи букви и знаци. За примера ще използваме bultuxpassword – на пръв поглед изключително елементарна и лесна за досещане парола. Но как да преобразуваме тази толкова елементарна парола в нещо по-сложно? Следвайки принципа – големи/малки букви, цифри и символи ние започваме да заменяме, така че за краен резултат получаваме:

Bu!TUx_p4sSW0rD

Е тази парола няма да намерите в списъците с пароли и ще е достатъчно сигурна. Разбира се не е най-сигурната парола, но със сигурност ще е по-добре от различни други комбинации. Ще ви дам още няколко примера:

godspower = g0d5_!p0w3r
Marlboro = m4r!b0rO_
и т.н.

Разбира се по-добрия и най-сигурен вариант за момента е използването на генерирана парола. Парола, която няма да е свързана с вас по никакъв начин и няма да има никакво значение. За целта можете да използвате различни приложения за генерирането на такива. Не съм се интересувал особено какви видео генератори на пароли има, но за тези от вас, които харесват езика за програмиране Python могат лесно и бързо сами да си спретнат един малък скрипт или пък да използват друг език за програмиране за да си направят малка програмка за целта. Принципа е следния според това каква парола искате да имате. Дали тя да бъде само от букви+цифри, дали да бъде букви+цифри+специални знаци, или пък да използвате шестнадесетичната бройна система. от там остава просто да създадете стринг и да използвате функцията за random във вашия език за програмиране, с който да изберете няколко символа от този стринг. Казах малко по-рано, че използвам Python за моя генератор, защото функцията string ми позволява да използвам и боравя с тези методи по-лесно. Следващото е само за тези, които се интересуват от това как става:
1. Създаваме метод, който да разбурка даден стринг и да върне паролата с определена дължина:

[python]def generate_sample(choices, length):
return random.sample(choices * length, length)
[/python]

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

[python]def alphanum(length):
sample = generate_sample(string.letters + string.digits, length)
return ”.join(sample)[/python]

За да използвате тези методи предварително ще трябва да се добавили във вашия скрипт следните библиотеки: random и string.

Ако все пак ви потрябва приложението можете да го изтеглите от BulTux. За целта ще е нужно да имате инсталиран Python:
pyspgen (64.36 KB) 151 изтегляния

За почитателите на bash можете да погледнете и друго решение:

[bash]#!/bin/bash

charspool=(‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’ ‘j’ ‘k’ ‘l’ ‘m’ ‘n’ ‘o’ ‘p’
‘q’ ‘r’ ‘s’ ‘t’ ‘u’ ‘v’ ‘w’ ‘x’ ‘y’ ‘z’ ’0′ ’1′ ’2′ ’3′ ’4′ ’5′ ’6′ ’7′
’8′ ’9′ ’0′ ‘A’ ‘B’ ‘C’ ‘D’ ‘E’ ‘F’ ‘G’ ‘H’ ‘I’ ‘J’ ‘K’ ‘L’ ‘M’ ‘N’ ‘O’
‘P’ ‘Q’ ‘R’ ‘S’ ‘T’ ‘U’ ‘V’ ‘W’ ‘X’ ‘Y’ ‘Z’ ‘!’ ‘£’ ‘$’ ‘%’ ‘&’ ‘=’ ‘.’ ‘,’ ‘;’ ‘:’ ‘-’ ‘_’);

len=${#charspool[*]}

if [ $# -lt 1 ]; then
num=6;
else
num=$1;
fi

echo -n "password: "
for c in $(seq $num); do
echo -n ${charspool[$((RANDOM % len))]}
done
echo[/bash]

Скриптът е взет от: My. Debian

Надявам се статията да ви е била полезна. Ако имате забележки или предложения за приложения, които да бъдат описания не се притеснявайте да ги запишете в коментарите.

]]> http://www.bultux.org/tutorials/kolko-sigurni-sa-parolite-koito-polzwame/feed 2 http://www.bultux.org/terminal/python-aktualna-pesen-w-clipboard http://www.bultux.org/terminal/python-aktualna-pesen-w-clipboard#comments Wed, 28 Oct 2009 16:02:52 +0000 Владимир Колев http://bultux.sikomi.com/?p=38
За този урок ще са ви необходими елементарни познания по програмиране с Python, и разбиране на командите в Linux терминала. Урокът може лесно да бъде пренаписан и на други езици: perl, bash, и т.н. Ето и какво ще прави нашият малък скрипт: Ще проверим дали плейърът, който използваме е включен След като е включен ще [...]]]>

За този урок ще са ви необходими елементарни познания по програмиране с Python, и разбиране на командите в Linux терминала. Урокът може лесно да бъде пренаписан и на други езици: perl, bash, и т.н. Ето и какво ще прави нашият малък скрипт:

1. Ще проверим дали плейърът, който използваме е включен
2. След като е включен ще използваме команда, която да изведе информация за свирещата в моемнта песен, и нашият скрипт ще я прочете
3. Скрипта ще форматира прочетената информация, за да я подреди във формата “Изпълнител – Заглавие”
4. След което ще използваме gtk библиотеката, за да копираме песента в clipboard
5. Ще разширим скрипта, за да издава приятени съобщения, когато е копирана песен

Преди да започнем ще трябва да се уверим, че системата ни е готова, т.е. че разполагаме с необходимите библиотеки. За целта са ни необходими:

• python >=2.5
• python-notify
• python-gtk2

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

Скелет на скрипта:

Ще започнем със създаването на скелет за нашият скрипт, който в последствие ще разширим. Първоначално ще създадем метод cur_song(), който ще проверява и събира информация за свирещата песен. Причината да правиме това, е за да можем да използваме скрипта и в други наши програми. След което ще инициализираме метода и ще го изпълним при стартиране на програмата с if __name__ = “__main__”: , където ще инициализираме и метода за записване в clipboard-а.

Така GTK ни предлага един много елементарен инструмент, който ще ни помогне за копиране на песента в Clipboard. За целта първо трябва да създадеме променилва clipboard, която да приеме метода за отваряне на clipboard, след което ще зададем променливата да приеме стойност от нашия метод cur_song(), и накрая ще запишеме промяната – три реда по-близко до целта ;) :

	clipboard = gtk.clipboard_get()
	clipboard.set_text(cur_song())
	clipboard.store()

Вземане на информацията от плейъра

За да вземем информацията от плейъра, първо трябва да определим, кой плейър ще използваме. Нека за примера вземем Rhythmbox, ще видите че метода е приложим и за други аудио плейъри като:  exaile, banschee, quodlibet, listen, mocp.

Първо да разберем как всъщност функционира самия метод:

1. Много добре знаем, че всяка стартирана програма създава процес и това кои процеси в работят в момента на компютъра можем да проверим с командата ps -A, и за да проверим за точно определена програма можем да използваме командатата grep <име_на_програмата>. Като резултат получаваме командния ред: ps -A | grep rhythmbox

2. От нашият скрипт много лесно можем да добавим изпълнението на командата посредством метода exec, но така няма да можем да прочетем изхода от командата. За целта ще използваме библиотеката os, която съдържа и метода popen, с който да прочетем изхода от изпълнената команда.

3. Към Rhythmbox има приложение с името rhythmbox-client, което ни предосравя достъп до Rhythmbox от командния ред. Добавяйки параметъра –print-playing получаваме точно това, което ни трябва – свирещата в момента песен.

След като разполагаме с горните знания вече няма да ни бъде никак трудно да ги приложиме в нашия метод cur_song():

	# Проверяваме дали rhythmbox е включен
	if "rhythmbox" in os.popen('ps -A | grep rhythmbox').readline():
		# Прочитаме свирещата в момента песен и премахваме новия ред от изхода, за да получиме само един ред
		song = os.popen('rhythmbox-client --print-playing').readline().replace('\n', '')
	else:
		return "No song playing"
	# Тъй като това е метод - връщаме съдържанието на променливата
	return song

И това е като цяло скрипта в няколко реда. При изпълнението му няма да се случи абсолютно нищо – т.е. нищо няма да видите, но ако отворите текстов редактор и изберете опцията paste, ще получите свирещата песен в момета :)

Разширяване на скрипта

За да разширим нашият скрипт и да знаеме, дали работи правилно ще използваме библиотеката notify, която ни предоставя възможност да пращаме съобщения до notify системата на Linux. Преди това обаче, ще си добавиме възможност да включваме и изключваме системата за известия – за целта ще създаден след дефинирането на библиотеките глобална променлива show_notifications = 1. И в зависимост от това, дали стойността е 0 или 1, ще определяме дали известяването е включено или изключено. Първо ще ви покажа кодовия блок, който добавяме към края на скрипта – след clipboard.store():

if show_notifications == 1:
		try:
			import pynotify
			if pynotify.init("playCopy"):
				n = pynotify.Notification("playCopy", "\n%s" % clipboard.wait_for_text(), "audio-volume-medium")
				n.show()
		except:
			print "You don't have pynotify installed!"

Ето и какво се случва. Ако променливата ни show_notifications иа стойност 1, то тогава ще се опитаме да вмъкнеме библиотеката pynotify. Ако не е вмъкната, значи че не е инсталирана. След което следва условието pynotify.init(“playCopy”) – това е много важно, защото без него нашия скрипт няма да работи – това, което прави е да съобщи на notify, че нашия скрипт си има има playCopy, с което да го идентифицира. и след това взимаме съобщението, което последно нашият скрипт е записал в clipboard за да го покажеме n.show().

Можете да изтеглите и пълния скрипт за програмата:

PlayCopy Script (33.37 KB) 120 изтегляния