FLLOG » python

Py4A czyli piszemy aplikację na androida.

Michał — Wed, 01 Jun 2011 18:40:17 +0000

Jak obiecałem jest to krótki opis w jaki sposób zmajstrować aplikację z prostym GUI napisaną w pythonie na androida. Py4A ma wiele funkcji ale niestety brakuje mu dostępu do podstawowych funkcji do tworzenia interfejsów dla androida. Konieczne jest posiłkowanie się WebView czyli htmlem oraz javascriptem. Jeśli nadal jesteś chętny to czytaj dalej.

Muszę zaznaczyć na samym początku artykułu, że kod nie jest doskonały a sam przykład nie jest może do końca przemyślany. Należy to traktować jako wstęp do swoich aplikacji i drogowskaz. Jeśli ktoś ma uwagi odnośnie kodu to proszę bardzo jednak dużo bardziej jestem zainteresowany innymi sposobami użycia pythona na androidzie. Kod sam w sobie nie wykonuje żadnych skomplikowanych operacji na sprzęcie, pomimo że API to umożliwia, jak już pisałem przykład nie jest do końca przemyślany a moim celem było tylko pokazanie, że aplikacje mogą posiadać interfejs a nie być po prostu skryptami. Koniec biadolenia, przechodzimy do mięska.
Najskromniejsza z aplikacji to tak naprawdę dwa pliki. Py który zawiera kod, mechanikę, funkcje itd. oraz html czyli interfejs. Python zaakceptuje wszystko pod warunkiem oczywiście, że są odpowiednie moduły. Html natomiast przyjmie js oraz css więc daje duże możliwości.
Oto plik .py, opiszę poszczególne fragmenty.

import android

droid = android.Android()
droid.webViewShow('file:///sdcard/sl4a/scripts/gasoline_ui.html')
while True:
    dist = droid.eventWaitFor('dist').result['data']
    gas = droid.eventWaitFor('gas').result['data']
    res = float(gas) / float(dist) * 100
    droid.dialogCreateAlert('Wynik kalkulacji', 'Spalanie: %s' % res)
    droid.dialogSetNeutralButtonText("Ok")
    droid.dialogShow()
    result = droid.dialogGetResponse().result
    droid.dialogDismiss()

Początek jest na tyle prosty, że nie ma co pisać. W pętli dzieje się cała mechanika, python czeka w niej na zdarzenia uruchamiane przez użytkownika w wymienionym wcześniej pliku html (o nim później). Wartości przypisywane są do odpowiednich zmiennych a potem wynik jest wypluwany w formie okna dialogowego. Żadnych trudności, wszystko proste i przyjemne.
A teraz plik html.


  
    
    Kalkulator spalania
    
  
  
    
      Ile przejechałeś?
      
      

      Ile zatankowałeś?

Najważniejszą częścią tego pliku jest javascript, który również tworzy obiekt API i poprzez jego metody komunikuje się z pythonem, odpowiedzialna jest za to funkcja eventPost(). Nie jest to zbyt skomplkowane. Jak już ma oba pliki to najlepiej je popchnąć na urządzenie używając adb (rozważam opisanie instalacji i konfiguracji w osobnym poście) poleceniem

adb push plik.py /sdcard/sl4a/scripts/
adb push plik.html /sdcard/sl4a/scripts/

Po tej operacji SL4A umożliwi odpalenie programu z listy skryptów.

Nie jest to piękne rozwiązanie ale umożliwia to zabawę pythonem, do czasu aż API nie będzie wspierać natywnych okienek lub nie pojawi się PyQT lub PyGTK trzeba będzie tak pisać lub przerzucić się na javę.

Py4A czyli piszemy aplikację na androida. to wpis z FLLOGa

Py4A – Python w Androidzie

Michał — Wed, 25 May 2011 19:04:28 +0000

A więc kupiłeś telefon z androidem. Pierwsze dni byłeś ostrożny, tylko instalacja aplikacji i ustawianie telefonu. A potem rootujesz telefon i pierwsze mody. Po paru modach zaczyna się robić nudno trochę bo ile można brać a nic nie dawać w zamian. Znasz pythona i postanawiasz stworzyć coś swojego na telefon. I w tym miejscu przydaje się ten krótki artykuł.

Opiszę tutaj w jaki sposób zainstalować niezbędne programy na telefonie aby można było pisać aplikacje w pythonie. Sprawa jest banalnie prosta. Jedyne co potrzeba to telefon z androidem oraz dostęp do internetu na telefonie (najlepiej poprzez wifi, chyba że masz duże limity u operatora komórkowego) lub komputerze. Wygodniej jest użyć telefonu do pobrania aplikacji, oszczędzisz sobie kopiowania plików poprzez kabel lub bluetooth. Ok, masz wszystko? Zaczynamy.
Zanim zaczniesz instalować soft przejdź do ustawień w telefonie, do części odpowiedzialnej za aplikacje i włącz instalację programów z nieznanych źródeł.
Pierwsze co jest potrzebne to SL4A (Scripting Layer for Android) czyli program który umożliwi odpalanie programów napisanych w pythonie (i nie tylko. Perl, JRuby, Lua, BeanShell, JavaScript, Tcl, oraz shelle. Autorzy planują dodać inne języki.). Otwórz http://code.google.com/p/android-scripting/ w telefonie i kliknij w w kod QR, jest duży i łatwiejszy do trafienia niż linki po lewej stronie. Plik który instalujesz to sl4a_r4.apk. Po instalacji w menu pojawi się SL4A ale po uruchomieniu jest pusty.
Następny krok to instalacja pythona czyli Py4A (Python for Android). Są dwie możliwości: instalacja ze strony SL4A lub ze strony Py4A gdzie umieszczona jest nowsza wersja. Jeśli wybrałeś pierwszą opcję to po lewej stronie w menu Downloads kliknij na PythonForAndroid_r4.apk i zainstaluj. W drugim wypadku przejdź na http://code.google.com/p/python-for-android/ i analogicznie w sekcji Downloads kliknij na PythonForAndroid_r5.apk.
Następny krok jest taki sam, niezależnie od wybranej wersji. W menu telefonu znajdź i odpal Python For Android, z pewnością poznasz ikonkę. Na ekranie zobaczysz wersje pythona oraz dodatków które masz zainstalowane. W tej chwili nie powinieneś mieć żadnych numerów więc trzeba wcisnąć Install i poczekać aż aplikacja pobierze i rozpakuje wszystko. Po tej operacji w SL4A w menu Scripts będą widoczne przykładowe skrypty pythonowe. Polecam odpalić parę, klikając na wybranym i wybierając ikonę terminala a następnie obejrzeć kod wybierając ikonę ołówka.
To wszystko, w następnych artykułach postaram opisać jak napisać aplikację a także jak zbudować paczkę apk. Dla niecierpliwych parę stron lektury: opis API oraz lista metod API.

Py4A – Python w Androidzie to wpis z FLLOGa

Przedszkole w edytorze

Michał — Mon, 02 May 2011 09:16:39 +0000

Formatowanie kodu jest ważne. To jest fakt. Ostatnio zetknąłem się z ciekawymi próbami sprawienia aby kod był bardziej czytelny, niestety nie udało mi się opisać tego przed moim znajomym. Polecam lekturę pod którą podpisuję się obiema rękami. Ze swojej strony pragnę dodać tylko bardzo „ciekawy” sposób definiowania zmiennych albo słowników. Za pewne można użyć go w innych przypadkach ale nie mam zamiaru marnować czasu na wymyślanie takich bzdur.

Jeśli piszesz w taki sposób to robisz to źle.

pierwsza_zmienna_od_długiej_nazwie                = 1
druga                                             = 2
trzecia_zmienna                                   = 3
czwarta_zmienna_o_długiej_nazwie_i_jeszcze_trochę = 4

Piękne, prawda? Ostatnią dodałem specjalnie najdłuższą aby pokazać bzdurność takiej konstrukcji. Po jej dodaniu musiałem przesunąć inne znaki przypisania w zmiennych wpisanych wcześniej!! Cóż za prostota rozwiązania.

dict = {
'pierwsza'                                          : 1,
'druga'                                             : 2,
'trzecia_zmienna'                                   : 3,
'czwarta_zmienna_o_długiej_nazwie_i_jeszcze_trochę' : 4
}

Kolejny cudowny przykład.
Uważam to za błąd w każdym języku ponieważ to zaciemnia tylko kod i wymusza liczenie spacji a potem przerabianie całej konstrukcji w wypadku gdy dodaje się zmienną o dłuższej nazwie. Taka metoda musi być popularna wśród szachistów gdzie ruchy należy planować odpowiednio przed.
Proszę nie piszcie tak. Szachiści również.

Przedszkole w edytorze to wpis z FLLOGa

devs y u no pep8 in Emacs

Michał — Wed, 16 Feb 2011 20:19:15 +0000

Tytuł dosyć niezrozumiały ale w luźnym tłumaczeniu jest to pytanie „dlaczego nie używasz pep8 w Emacsie?”. Czym jest pep8? Jest to lista zaleceń odnośnie stylu kodowania. Tak, zgadza się, są to zalecenia więc nie są przymusowe ale na tyle logiczne oraz przemyślane, że warto je stosować. W końcu standaryzacja to nie jest nic złego jeśli jest stosowana z umiarem oraz w odpowiednim miejscu. Jeśli interesuje Cię implementacja sprawdzania składni pod kątem pep8 w locie w Emacsie to czytaj dalej.
Wpis ten nie powstałby gdybym nie zmobilizował się lub nie został zmobilizowany do ustawienia sobie emacsa pod pep8. Aby ułatwić innym (oraz sobie bo mam tendencję do zapominania, potem sięgam do swojego bloga i voila) opiszę co trzeba zrobić aby cieszyć się pięknym kodem. Dla ludzi którzy wolą jednak nabywać wiedzę w tradycyjny sposób i reguły stosować klasycznie polecam ściągawkę do wydrukowania. Przejdę do rzeczy. Potrzebujesz Emacsa a do niego pep8, pyflakes oraz flymake-cursor (to modyfikacja aby informacja o błędzie pojawiała się w minibuforze). Narzędzia pep8 oraz pyflakes łatwo zainstalować przy użyciu pipy.

pip install pep8 pyflakes

Natomiast flymake-cursor już trzeba ręcznie skopiować i zapisać jako flymake-cursor.el na ścieżce z plikami el. Ja zapisałem w /usr/share/emacs/site-lisp. Kolejny krok to modyfikacja pliku konfiguracyjnego .emacs. Należy dokleić do niego poniższy kod.

(add-hook 'find-file-hook 'flymake-find-file-hook)
(when (load "flymake" t)
  (defun flymake-pyflakes-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
               'flymake-create-temp-inplace))
       (local-file (file-relative-name
            temp-file
            (file-name-directory buffer-file-name))))
      (list "pycheckers"  (list local-file))))
   (add-to-list 'flymake-allowed-file-name-masks
             '("\\.py\\'" flymake-pyflakes-init)))
(load-library "flymake-cursor")
(global-set-key [f10] 'flymake-goto-prev-error)
(global-set-key [f11] 'flymake-goto-next-error)

Ostatni krok to stworzyć plik o nazwie pycheckers gdzieś w PATH oraz ustawić go jako wykonywalny. W tym miejscu można skonfigurować sobie pep8, przydatne gdy wcięcia kodu nie są wielokrotnością 4.

#!/bin/bash

pyflakes "$1"
pep8 --ignore=E221,E701,E202 --repeat "$1"
true

Tyle wystarczy, pozostaje restart Emacsa lub M-x eval-buffer w otwartym buforze z plikiem .emacs i już można korzystać.
Całość to właściwie opis ze strony http://www.saltycrane.com/blog/2010/05/my-emacs-python-environment/ i polecam zajrzeć do źródła gdzie można znaleźć parę innych smaczków do emacsa.

devs y u no pep8 in Emacs to wpis z FLLOGa

django: unittest

Michał — Tue, 24 Aug 2010 08:50:25 +0000

Django jest pisane w pythonie, python jak każdy porządny język obsługuje testy jednostkowe. A więc Django również. Dzisiaj przedstawię po krótce jak wygląda sprawa z testami w Django. Rozprawkę oprę o unittesty z tego prostego powodu, że podobają mi się bardziej niż doctesty. Nie znaczy to, że są lepsze po prostu służą do testowania innych przypadków, nie są pythonic ale ładnie obiektowe i ja je wolę po prostu.

Załóżmy, że masz model reprezentujący wyniki rzutów kostką do gry, do modelu jest dodana metoda sprawdzająca czy wynik jest parzysty czy nie.

from django.db import models

class Kostka(models.Model):
    wynik = models.IntegerField()
    osoba = models.CharField(max_length = 10, default = 'Anonim')

    def _sprawdz_liczbe(self):
        if (wynik % 2):
            return 'Parzysta'
        else:
            return 'Nieparzysta'

    test_wyniku = property(_sprawdz_liczbe)

Na tym modelu chcemy wykonać następujące testy:

Tworzenie obiektu (pole ‘wynik’ nie posiada wartości domyślnych)
Tworzenie obiektu z wartością domyślną
Test parzystości wyniku

Wszystkie testy dobrze trzymać w osobnym pliku, który nota bene jest tworzony wraz z projektem, plik tests.py znajduje się w katalogu aplikacji. Jest to wygodne i pozwala w łatwy sposób odnaleźć wszystkie testy w danej aplikacji. Zaczynamy od importów oraz stworzenia klasy testu.

import unittest
from aplikacja.app.models import Kostka

class KostkaTestCase(unittest.TestCase):

Następnym krokiem jest przeładowanie metody setUp() w celu stworzenia zmiennych lub obiektów odpowiadających naszym wymaganiom. Jak w pythonie i tutaj możliwe jest przeładowanie metod tearDown(), runTest() i suite() ale nie jest to konieczne. W opisywanym przypadku tworzone są trzy właściwości które posłużą później do tworzenia obiektów; rzutu parzystego, nieparzystego, zwykłego rzutu oraz anonimowego rzutu testującego wartość domyślną.

class KostkaTestCase(unittest.TestCase):
    def setUp(self):
        self.osoba = 'Michal'
        self.liczba_parzysta = 4
        self.liczba_nieparzysta = 5

Teraz czas na przygotowanie testów. Na pierwszy ogień idzie test tworzenia obiektu z podanymi obiema wartościami: osoba i wynik. Test powinien przejść bez żadnych problemów.

class KostkaTestCase(unittest.TestCase):
...
    def test_tworzenie_obiektu(self):
        rzut = Kostka.objects.create(self.liczba_parzysta, self.osoba)
        self.assertTrue(rzut)
        self.assertEqual(rzut.wynik, 4)
        self.assertEqual(rzut.osoba, 'Michal')

Następny test to sprawdzenie czy pole osoba przyjmuje wartość domyślną.

class KostkaTestCase(unittest.TestCase):
...
    def test_wartosci_domyslnej(self):
        rzut_anonim = Kostka.objects.create(self.liczba_parzysta)
        self.assertTrue(rzut_anonim)
        self.assertEqual(rzut_anonim.osoba, 'Anonim')

Kolejny test i ostatni, którego kod zaprezentuję to test parzystości. Drugi test jest analogiczny i nie widzę potrzeby umieszczania kodu. W tym przypadku nie testujemy czy obiekt został stworzony ponieważ jest to w poprzednich testach.

class KostkaTestCase(unittest.TestCase):
...
    def test_parzystosci(self):
        rzut_parzysty = Kostka.objects.create(self.liczba_parzysta)
        self.assertEqual(rzut_parzysty.test_wyniku, 'Parzysty')

To wszystkie potrzebne testy, w tym momencie można je uruchomić i sprawdzić czy nasze testy lub model są poprawne. Do wykonania tego służy znany wszystkim manage.py.

./manage.py test app

Jeśli wszystko pójdzie dobrze to powinien ukazać się następujący listing, jeśli nie to opis błędu jest na tyle jasny (czasem stworzony przez nas), że szybko można poprawić test lub model.

----------------------------------------------------------------------
Ran 4 tests in 0.009s

OK
Destroying test database 'default'...

Jak widać jest to łatwe i przyjemne oraz w pełni zgodne z Pythonem. Koniec, wszystkim życzę 100% skuteczności wykonywanych testów.

django: unittest to wpis z FLLOGa

Dajax i jquery 1.4.2

Michał — Mon, 05 Jul 2010 21:28:11 +0000

Siedzę nad dużą aktualizacją mojego amatorskiego projektu www.gdziebylkaziu.pl i zaplanowałem sobie dorzucić trochę ajaxa do map google. Szperając po internecie znalazłem http://dajaxproject.com i zakochałem się, dzięki temu mogę wszystkie proste funkcjonalności ajax napisać w … pythonie! Cieszę się ponieważ pomimo tego, że javascript jest ok to wolę pythona, oj wolę. Przechodzimy do rzeczy. Ostrzegam rozwiązanie jest banalne i pewnie wiele osób na to wpadło.Na stronie dajaxproject jak byk stoi, że wspierane są biblioteki jQuery 1.3.2 ale ja jestem niedowiarkiem, po prostu uważałem, że zmiany w stosunku do wersji 1.4.2 nie są aż tak duże. No ale się pomyliłem bo nie chciało działać. Funkcje jQuery addClass() lub removeClass() były wykonywane ale z parametrem którego nie akceptowały (zbadałem i wersja 1.3.2 nie ma takiego problemu). Rozwiązanie było proste jak drut a mianowicie skonwertować obiekty do łańcucha znaków czyli toString(). A teraz gdzie to zmieniamy, kod znajduje się w pliku jquery.dajax.core.js. Szukamy linijek

case 'addcc':
case 'remcc':

I do wywołań funkcji addClass() oraz removeClass() dodajemy toString()

case 'addcc':
jQuery.each(elem.val,function(){
$(elem.id).addClass(this.toString());
});
break;

case 'remcc':
jQuery.each(elem.val,function(){
$(elem.id).removeClass(this.toString());
});
break;

Prawda, że banalne. Następnie opiszę w jaki sposób używać dajax, jest to równie proste jak ten fix.

Dajax i jquery 1.4.2 to wpis z FLLOGa

Django i ajax

Michał — Fri, 23 Apr 2010 12:29:19 +0000

W mojej nowej pracy, pracuję tam 6 miesięcy to już nie jest tak nowa, dużo się uczę i dużo koduję. Między innymi używam sławnego jquery i ajaxa. Postanowiłem dołożyć obie rzeczy do django aby wszystko ładnie pięknie ze sobą współgrało. Założenie było proste, pewne elementy strony mają być dynamicznie odświeżane. W moim projekcie wyświetlam statystyki na stronie głównej używając właśnie ajaxa i jquery aby były one w miarę aktualne (w czasie rzeczywistym można rzec).

Info: Django plus ajax. Jeśli mocniejszą stroną u Ciebie jest python niż javascript, może zainteresuje Cię Dajax? Nie, to czytaj dalej.
Pierwsze czego potrzebujemy to kod w pliku views.py (oczywiście z odpowiednim wpisem do urls.py)

def informacja(request):
    if request.is_ajax():
      return HttpResponse(u'Wywołanie ajax wykonano.')

A kolejny kod to javascript który nam to ładnie obsłuży. W tym wypadku wsadzi do elementu div.

$.ajax({
   type: 'POST',
    url: '/adres_do_uslugi',
   success: function(j) {
       $('#informator').html(j);
        }
});

Tyle drodzy państwo. Naprawdę proste a możliwości niezliczone.
p.s.
Czy zna ktoś jakiś ciekawy plugin WordPress`a do prezentacji kodu?

Django i ajax to wpis z FLLOGa

Jak dołączyć %changelog, %post_install i %post_uninstall do pliku spec używając distutils i setup.py

Michał — Wed, 17 Feb 2010 07:00:38 +0000

Ostatnimi czasy moją głowę zaprzątał problem stworzenia paczki rpm dla mojego programu SynapticsConfig. Długo walczyłem z jednego powodu, chciałem użyć distutils a nie ręcznie tworzyć plik spec. Poniżej przytoczę problemy z którymi się borykałem oraz rozwiązania tych problemów. Wg. mnie dokumentacja distutils i pythona dotycząca zagadnień które poruszam jest dosyć skromna i wszelkie próby znalezienia rozwiązania dawały mierne wyniki. Całe szczęście mamy listy dyskusyjne oraz od źródłowy (fuck you propietary software!).

Dołączanie %changelog

Część pliku spec odpowiedzialna za changelog jest wymagana, tak przynajmniej uważa rpmlint oraz tak stoi w dokumentacji Fedory. W dokumentacji distutils nie ma zbyt wielu informacji na ten temat. Jednak naprowadziła mnie ona na proste rozwiązanie a mianowicie

python setup.py bdist_rpm --help

Komenda wyświetla dokładnie to czego potrzeba czyli

--changelog          RPM changelog

To mogłoby załatwić sprawę gdyby nie brak informacji w jakiej postaci ma być changelog. Wszystko wskazuje, że to powinien być plik jednak domyślne formatowanie nie spełniało wymagań i ładnie wypluwało komunikat, że wiersz musi zaczynać się od „*”. Postanowiłem zerknąć do pliku odpowiedzialnego za generowanie paczek rpm /usr/lib64/python2.6/distutils/command/bdist_rpm.py. Na początku pliku wśród listy opcji pojawia się taki tekst

# More meta-data: too RPM-specific to put in the setup script,
# but needs to go in the .spec file — so we make these options
# to „bdist_rpm”. The idea is that packagers would put this
# info in setup.cfg, although they are of course free to
# supply it on the command line.

No ładnie ale ja z lini poleceń nie mogłem dołączyć changelog więc z pomocą przyszedł plik setup.cfg. Do pustego pliku dodałem linijkę

[bdist_rpm]
changelog = #tutaj tekst changelog oczywiście zaczynający się od *

Należy pamiętać o gwiazdce ropoczynającej każdą wersję oraz o poprawnym formacie daty. Rpm jest bardzo wymagający w tym temacie. Tak przygotowany changelog powinen przejść proces budowania paczki.

Dodawanie %post_install i %post_uninstall

Kolejne rzeczy, które musiałem skonfigurować to sekcje kodu uruchamiane po zainstalowaniu paczki i jej odinstalowaniu. Wspomniany wcześniej bdist_rpm –help tak opisuje to

–post-install Specify a script for the post-INSTALL phase of RPM
building
–post-uninstall Specify a script for the post-UNINSTALL phase of RPM
building

W tym wypadku jednak nie używałem linii poleceń ani pliku setup.cfg. Te dwie opcje pozwoliły sie zgrabnie dołączyć do pliku setup.py jako argument funkcji setup

options={'bdist_rpm' : {'post_install'  : 'ścieżka_do_pliku', 'post_uninstall'  : 'ścieżka_do_pliku'}}

Bardzo możliwe, że zamiast podawania ścieżek do istniejących plików można wsadzić komendy. W wypadku skryptów mających parę linijek może pojawić się problem, ale nie testowałem.

Mam nadzieję, że przybliżyło to co niektórych do stworzenia własnej paczki rpm przy użyciu distutils. To dlaczego wybrałem %post_install i %post_uninstall zostało podyktowane sposobem uruchamiania mojego programu i niemożliwością (spodowoaną może brakiem wystarczającej wiedzy) dodania linka do pliku w paczce rpm. Z wielką chęcią przyjmę wszelkie uwagi lub sugestie.

Jak dołączyć %changelog, %post_install i %post_uninstall do pliku spec używając distutils i setup.py to wpis z FLLOGa

Odpicuj backintime

Michał — Mon, 17 Aug 2009 10:00:54 +0000

Jak wiadomo istnieją dwie grupy użytkowników, pierwsza robi kopie zapasowe a druga zacznie je robić. Ja przeszedłem do pierwszej i po dosyć długich poszukiwaniach znalazłem ciekawy program back-in-time, który załatwia za mnie tworzenie kopii zapasowych. Prosty i łatwy w obsłudze, idealnie nadaje się na desktopy. Jego jedyną wadą wg. mnie jest brak pakowania tworzonych katalogów z kopiami dlatego napisałem mały skrypt w pythonie, który załatwia to za mnie.

Jako argument bierze ścieżkę do katalogu w którym foldery musi spakować i po kolei pakuje do plików tar.bz2. Polecam dodanie do crontaba użytkownika root tak jak back-in-time.

Kod do pobrania, oczywiście dostępny na licencji GPLv3.

Odpicuj backintime to wpis z FLLOGa

Jak tłumaczyć łatwo w PyQt4 aplikacje

Michał — Sun, 09 Aug 2009 20:29:06 +0000

Interesuję się od pewnego czasu pythonem a od niedawna PyQt4. Dokumentacja jest naprawdę dobre zrobiona, co prawda nie jest to msdn ale jest dobrze. Postanowiłem się zabrać za tłumaczenie aplikacji przy użyciu właśnie PyQt4, może lepiej napisać Qt4. Nie potrafiłem znaleźć nic pomocnego w internecie więc zabrałem sie za czytanie książek i teraz wiem i mam zamiar się podzielić z ludźmi którzy mają taki sam problem jaki miałem ja: brak przykładów i jasnych instrukcji jak użyć funkcji tr() i translate().

Załóżmy, że posiadasz mały formularz stworzony w QtDesigner i dopisałeś do tego trochę swojego kodu.

from PyQt4 import QtCore, QtGui
import sys
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName('MainWindow')
        MainWindow.resize(365, 222)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.centralwidget.setObjectName('centralwidget')
        self.pushButton = QtGui.QPushButton(self.centralwidget)
        self.pushButton.setGeometry(QtCore.QRect(110, 70, 114, 27))
        self.pushButton.setObjectName('pushButton')
        MainWindow.setCentralWidget(self.centralwidget)
        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)
    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(QtGui.QApplication.translate('MainWindow', 'MainWindow', None, QtGui.QApplication.UnicodeUTF8))
        self.pushButton.setText(QtGui.QApplication.translate('MainWindow', 'Click', None, QtGui.QApplication.UnicodeUTF8))
class MyForm(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = MyForm()
    myapp.show()
    sys.exit(app.exec_())

Powyższy kod powstał już po edycji pliku z QTDesignera, do pliku wynikowego przetworzonego w pyuic4 dorzuciłem dwa dodatkowe bloki kodu. Inicjalizację formatki oraz klasę MyForm. Teraz ten plik zawiera całość kodu, który otwiera mini formatkę z jednym przyciskiem nad czym będziemy pracować. Pozwolę sobie omijać fragmenty kodu i podawać tylko istotne zmiany. Wiem, że w wypadku częstych zmian formatki lepiej jest ją trzymać w osobnym pliku i importować ale na potrzeby tego tutoriala jest to jeden plik.

Do pliku dodajemy kod podpinający sygnał clicked() do naszego przycisku i wykonujący stworzoną przez nas akcję. Dodajemy to do klasy MyForm.

QtCore.QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'), self.MessageBox)

Następnie piszemy funkcję MessageBox która wyświetli okienko potwierdzające, że akcja została wykonana.

def MessageBox(self):
    box = QtGui.QMessageBox(self)
    box.setWindowTitle(self.tr('information'))
    box.setText(self.tr('You have clicked button'))
    box.setStandardButtons(QtGui.QMessageBox.Ok)
    box.exec_()

Ten plik po uruchomieniu wyświetli okno z jednym przyciskiem po kliknięciu którego wyświetli się messagebox. Teraz zabierzemy się za tłumaczenie programu. Przechodzimy do sedna.

Wymienione przeze mnie funkcje odpowiadają za tworzenie plików .ts do tłumaczeń. Konwencja używania funkcji jest następująca, translate() używane jest dla tekstów będących poza klasami (QTDesigner wszystko wsadza do funkcji translate(), funkcja wymaga podnia kontekstu w jakim znajduje sie łańcuch), funkcja tr() jest dla wszelkich łańcuchów będących w środku klas a trUtf8() dla łańcuchów UTF8. Proste jak drut a przykłady użycia są w kodzie.

Następnym krokiem jest zmodyfikowanie aplikacji aby ładowała tłumaczenie automatycznie na podstawie zmiennej &LANG. Dodajemy kod do funkcji inicjalizującej (jako, że nie jestem pewny o czym piszę to mam na myśli if __name__ == „__main__”:)

locale = QtCore.QLocale.system().name()
appTranslator = QtCore.QTranslator()
if appTranslator.load('okno_ui_' + locale):
    app.installTranslator(appTranslator)

Dzięki temu program będzie uruchamiał odpowiednie tłumaczenie, jeśli plik z tłumaczeniem nie zostanie odnaleziony zostanie załadowany domyślny język(w tym wypadku angielski gdyż taki został użyty w kodzie). Dla języka polskiego program będzie próbował załadować tłumaczenie z pliku okno_ui_pl_PL.qm. Nie jest konieczne dodawanie rozszerzenia .qm. Takich plików jeszcze nie mamy, najpierw należy stworzyć plik .pro zawierający wszelkie pliki .ui, .py, .pyw oraz .ts (co ładnie rozwija się w translation source). Ja zazwyczaj nie dodaję plików .ui z powodu tego, że formularze przerabiam potem troszkę na własną rękę poprawiając kod i później mam zamieszanie w pliku .ts. Trudno mi powiedzieć czy jest to dobra czy zła praktyka, mam zbyt małe doświadczenie. Drobne uaktualnienie odnośnie dodawania plików .ui, w tej chwili jednak wolę trzymać formularz stworzony w QtDesigner w osobnym pliku, przyspiesza to dokonywanie zmian. Jednak dla potrzeb tego poradnika jest to wsadzone do jednego pliku, mniej plików = mniejsze zamieszanie. Oto plik .pro.

SOURCES = okno_ui.py
TRANSLATIONS = okno_ui_pl_PL.ts

W wypadku dodawania plików .ui potrzebna jest linijka FORMS =. Następnie wykonujemy polecenie pylupdate4 a jako argument podajemy stworzony plik .pro i otrzymujemy gotowy plik .ts który mozna przetłumaczyć. Tłumaczenia robimy w programie QtLinguist, a gotowe pliki .ts przetwarzamy programem lrelease-qt4 który tworzy nam pliki .qm. Koniec pracy. Jeśli w katalogu aplikacji znajdzie się plik .qm dla odpowiedniego języka systemowego to tłumaczenie zostanie załadowane w innym wypadku program otworzy się w języku angielskim.

W wypadku jeśli chcemy dołożyć tłumaczenie nalęzy po prostu dodać odpowiedni plik .ts do posiadanego pliku .pro i ponownie uruchomić pylupdate4, QtDesigner, lrelease-qt4 i tak w koło Macieju.

Dziękuję za uwagę.

Jak tłumaczyć łatwo w PyQt4 aplikacje to wpis z FLLOGa