Python blogowo.net

PyQt4 dostępne w Maemo

2010-02-09T14:58:28+00:00

PyQt w wersji 4.7 trafiło do repozytorium "Extras" systemu Maemo napędzającego smartphony Nokii: N800/N810/N900. PyQt możne korzystać z Qt 4.5 (Extras) lub Qt 4.5 (Extras-devel), dodano także zestaw przykładowych aplikacji i pomocniczych narzędzi jako pakiet python2.5-qt4-doc. Więcej można znaleźć na stronach maemo.org #python, #maemo, #qt

Django 1.2 beta 1 wydana

2010-02-06T04:44:29+00:00

Kilka godzin temu wydano Django 1.2 Beta 1 - kolejny krok do stabilnego wydania 1.2. Zmiany w Beta 1 obejmują: zmiany w testach, klas feedów, czy enkodowanie znaków , i ; w wartościach cookie. Nowości to nadawanie uprawnień na obiekt, uprawnienia dla anonimowego użytkownika oraz usprawnienia select_related. Szczegóły w notce wydania. Wersja stabilna powinna być wydana na początku marca. #django

Python 2.5.5

2010-01-31T16:20:11+00:00

Dzisiaj ukazała się piąta wersja poprawkowa Pythona 2.5. W wydaniu tym poprawiono jedynie błędy związane z bezpieczeństwem i udostępniono tylko wersję źródłową. Poprawki dotyczą modułów: - logging - tarfile - expat Wszystkim użytkownikom Pythona 2.5 zaleca się przesiadkę na najnowszą wersję z serii 2.x, Pythona 2.6.4. Więcej informacji jest dostępnych w pliku NEWS.txt. Żrodło: python.org

Epydoc - generowanie dokumentacji kodu

2010-01-31T05:18:12+00:00

Opis narzędzia epydoc do generowania dokumentacji kodu Pythona na podstawie docstringów #python, #django

Migracja videotesty.pl z PHP na Django/Python

2010-01-30T06:50:26+00:00

Podsumowanie zalet i efektów migracji serwisu videotesty.pl na Django/Python #django, #python, #php

PyYAML - parser formatu YAML

2010-01-28T18:54:50+00:00

Opis parsera YAML konwertującego dane zapisane w tym formacie do Pythonowych słowników.

Uwolnienie potęgi iPhona - jailbreaking

2010-01-17T14:22:02+00:00

Tak, jak pewnie większość użytkowników iPhone’a, mimo że słyszałem od dawna o możliwości zdjęcia apple’owskich blokad (proces określany jako jailbreaking), to trochę się obawiałem że taka operacja to potencjalne ryzyko zablokowania aparatu lub jakichś innych nieodwracalnych uszkodzeń. Prawda jest taka, że to wszystko to brednie i ploty. Jailbreak jest bardzo łatwy do przeprowadzenia i jest to proces w pełni odwracalny.

Jailbreak iPhone’a wytrąca z ręki krytyków tego urządzenia większość argumentów. Nie wszyscy wiedzą, ale Cydia (jedno z najpopularniejszych zasobów aplikacji na jailbreakowanego iPhone’a) istniała na długo zanim Apple wpadł na pomysł ze swoim AppStore. Aktualnie istnieje już wiele tego typów repozytoriów aplikacji, wszystkie są integrowane w jeden, szybki system za pomocą pakietu Rock (o czym niżej).

Czy są jakieś wady (lub ograniczenia) związane z jailbreakiem? Owszem, jest pewna niedogodność. Przed aktualizacją kolejnej wersji systemu operacyjnego iPhone\a (co jest dosyć rzadkim wydarzeniem) należy przywrócić z powrotem oryginalny system, zrobić aktualizację, i dopiero po tym odpalić ponownie jailbreak (choć przy większych zmianach iPhone OS można się wcześniej upewnić czy jailbreak już jest z nim kompatybilny).

Dla pewności, dobrze zrobić sobie backup iPhone (oczywiście za pomocą ITunes). Gdyby cokolwiek poszło źle można łatwo odzyskać z powrotem poprzednią zawartość iPhone’a.

Jailbreak (przy okazji usuwany jest simlock) przeprowadza się w banalny sposób. Należy podpiąć iPhone kabelkiem USB do komputera i uruchomić program blackra1n ściągnięty ze strony http://www.blackra1n.com (program jest dostępny zarówno dla Mac OS-X jak i dla sytemu Windows)

Po kliknięciu w przycisk “make it ra1n”, może pojawić się okienko ITunes z informacją że iPhone został przełączony w tryb recovery. Można je spokojnie zignorować.

Po odpaleniu blackra1n iPhone zostanie przeładowany, a na liście aplikacji pojawi się dodatkowa blackra1n. Należy ją uruchomić. Z zaproponowanych do instalacji pakietów: Cydia, Rock i sn0w. Należy wybrać Rock (zobacz: http://www.rockyourphone.com). Jest dużo szybszy od Cydii i oczywiście wszystkie aplikacje dostępne dla Cydii są też dostępne dla Rock’a. Poza tym Rock posiada automatyczny system backupu. Wystarczy zarejestrować sobie darmowe konto na serwerze (robi się to z poziomu Rock’a) i wtedy nie trzeba się przejmować aby robić backup ściągniętych aplikacji. Rock zrobi to automatycznie i automatycznie je przywróci jak trzeba. Do kontrolowania pakietów/aplikacji Rock używa APT, system podobny do używanego w Debianie/Ubuntu, lecz wszystko działa w ładnym GUI.

Jeśli po jailbreake’u masz jakieś problemy z działaniem Wifi, należy zrestartować w iPhonie ustawienia sieciowe (Ustawienia -> Ogólne -> Wyzeruj -> Wyzeruj ustawienia sieciowe) Ja musiałem to zrobić dwa razy. Od tego momentu już więcej nie było problemów.

Co warto sobie zainstalować na początek?

Na pewno warto zacząć od SBSettings (oczywiście wszystko się instaluje za pomocą aplikacji Rock). SBSettings to b. wygodna aplikacja, pozwala ubijać inne aplikacje, wyświetla ilość dostępnego RAM’u, pozwala czyścić RAM, chować ikony innych aplikacji itp.

Drugą aplikacją “must have” to Backgrounder – służy do odpalania dowolnej innej aplikacji w tle.

Trzecią to Categories pozwalająca na grupowanie ikon programów w foldery. Dużo wygodniej niż stary bałagan, zwłaszcza jak się ma dużo aplikacji.

Do łatwiejszej lokalizacji aplikacji (bo są w katalogach o mało czytelnych nazwach) dobrze doinstalować sobie Prostą aplikację AppLinks (w /var/mobile/AppLinks stworzy czytelne linki symboliczne do wszystkich aplikacji).

Co dalej? No, zależy co kto potrzebuje. Ja zainstalowałem sobie Pythona, Ruby, Haskella, Javę (kompaktowa JamVM), Scalę, Clojure, Vim’a, Midnight Commandera, wget, lynx, git, svn oraz oczywiście serwer OpenSSH. Dzięki temu ostatniemu mogę połączyć się z iPhonem za pomocą SSH (dla tych co nie wiedzą, domyślne hasło root’a w iPhonie to “alpine”). Dzięki SSH można łatwo modyfikować dowolne pliki i aplikacje. Przeszkadzają komuś reklamy w jakimś programie? :) Najczęściej wystarczy tylko prosta edycja pliku javascriptowego. Poza tym za pomocą SFTP można przerzucać dowolne programy i pliki z pominięciem iTunes. Jest nawet program Installous specjalnie do instalowania aplikacji bez pośrednictwa ITunes.

$ ruby -v
ruby 1.8.6 (2007-09-24 patchlevel 111) [arm-darwin9]

$ python    
Python 2.5.1 (r251:54863, xx/xx/xx, xx:xx:xx) 
[GCC 4.2.1 (Based on Apple Inc. build 5555)] on darwin

$ java -version
java version "1.5.0" 
JamVM version 1.5.1
Copyright (C) 2003-2008 Robert Lougher <rob@lougher.org.uk>
...
Execution Engine: direct-threaded interpreter with stack-caching
Compiled with: gcc 4.2.1 (Based on Apple Inc. build 5555)

Boot Library Path: /usr/lib/classpath
Boot Class Path: /usr/share/jamvm/classes.zip:/usr/share/classpath/glibj.zip

Python zainstalował mi się w wersji 2.5. Za pomocą setuptools doinstalowałem ipythona, django, pylons, sqlalchemy, mako. Odpaliłem prosty projekt w Django. Działa bez problemu. Ruby instaluje się w wersji 1.8.6 ale ma starsze RubyGems 1.3.2. Ściągnąłem zatem z sieci najnowsze i bez problemu doinstalowały się: Rails, Merb i Sinatra. Niestety jako serwer działa tylko Webrick. Thin i Mongrel się nie skompilowały, ale to dlatego że nie miałem programu make.

Powodzenia w hackowaniu. Teraz to iPhone naprawdę Rocks ;)

Sortowanie danych w MySQL i Django

2010-01-07T14:49:42+00:00

Przykład niestandardowego sortowania za pomocą metody extra ORM Django. #django, #mysql

Wyciąganie i konwersja MVE z Baldurs Gate do formatu mp4

2010-01-07T09:07:29+00:00

Wykorzystanie modułu struct Pythona oraz FFmpeg do wyciągnięcia i skonwertowania klipów wideo z Baldurs Gate. #python, #baldur, #baldurs, #ffmpeg

Django 1.2 alfa 1

2010-01-06T16:22:52+00:00

W środę wydano pierwszą wersję alfa nowej wersji Django 1.2. Dostępna jest szczegółowa notka wydania, jak i opis rozbudowanego systemu wiadomości (messages).

Z wstecznie niezgodnych zmian można wymienić zmiany w ochronie CSRF jak i brak obsługi zmiennych o nazwach: and/or/not w tagu {% if %}. Zmienia się także format zapisu danych bazy danych (obecny będzie obsługiwany do Django 1.4) ze względu na wprowadzenie obsługi wielu baz danych. Z nowości pojawiły się także wtyczki do wysyłania maili, czy pole BigIntegerField (64 bitowy integer). Planowo stabilna wersja 1.2 ma ukazać się 9 marca.

#django

Plan wydania Pythona 3.2

2009-12-30T19:49:02+00:00

Georg Brandl opublikował PEP-0392 (Python Enhancement Proposals), w którym zamieścił plan wydania Pythona 3.2. Ci, którzy spodziewają się znaczących zmian w języku, zawiodą się, gdyż PEP-3003 (Python Language Moratorium), o którym pisaliśmy tutaj, ciągle obowiązuje. Pierwsza alfa spodziewana jest na początek czerwca, a wydanie końcowe w grudniu 2010 roku. Planowane zmiany można śledzić na bieżąco w dokumencie 'What's new' z dokumentacji Pythona 3.2. Więcej informacji: PEP-0392 Źródło: python.org

IronPython 2.6

2009-12-16T22:57:04+00:00

Po ponad pół roku pracy, 11 grudnia, ukazała się ostateczna wersja IronPythona 2.6, finalne wydanie poprzedziła jedna alfa, dwie bety, oraz trzy wydania Release Candidate. Jest to pierwsza, z alternatywnych implementacji, wersja Pythona, zgodna z najnowszym standardem serii 2.x. Do głównych zmian można zaliczyć: - Lepsza integracja z .NET - Najnowsza wersja DLR - Przyśpieszenie działania, w szczególności szybszy start - Dodanie brakujących funkcji z poprzednich wersji CPythona oraz poprawa wielu zgłoszonych błędów Szczegółowe informacje na temat IronPythona można uzyskać na nowo powstałej stronie: ironpython.net. Pobierz: IronPython 2.6

GtkTreeView w Glade

2009-12-14T20:16:28+00:00

To co zawsze było dla mnie problemem w GTK+, to wszelkiego rodzaju listy danych. Mimo takich bibliotek jak kiwi, zawsze zastanawiałem się, dlaczego w GTK jest to takie trudne i nie można tego zrobić w glade.

Glade wraz z każdym kolejnym wydaniem przynosi sporo zmian. Używając wersji 3.6.7 i biblioteki GtkBuilder, udało mi się ~~prawie~~ w całości wyklikać widok drzewa wraz z modelem! Ponieważ nie znalazłem żadnego opisu i zajęło mi to trochę czasu, poniżej krótki przykład jak to zrobić, wraz z linkiem do repozytorium zawierającego dobrze opisany kod.

Glade 3

Jaki jest glade, każdy widzi i chyba nie ma się nad czym specjalnie rozpisywać. Po lewej stronie można wybrać widget, aby następnie umieścić go wewnątrz innego. Po prawej obejrzeć można drzewo obiektów i ustawić ich atrybuty oraz obsługę sygnałów.

W utworzonym przeze mnie modelu ważne są trzy elementy:

treeview, który odpowiada za wyświetlanie danych
combobox_parent, który pozwala na wybranie rodzica dla właśnie umieszczanych w drzewie danych
treestore - model w którym trzymane są dane wyświetlane przez dwa powyższe widoki

Wszystkie obiekty należy odpowiednio skonfigurować - ustawić kolumny i każdemu widokowi przyporządkować model, a każdej kolumnie obiekt renderujący.

Krótki opis przykładu

Aplikacja pozwala na zapisywanie danych tekstowych, ze wskazaniem rodzica dla wprowadzanego tekstu. Po lewej stronie jest combobox który współdzieli model razem z głównym treeview i pozwala wybrać rodzica. Na prawo od niego jest entry do wprowadzania danych i button do potwierdzenia i zapisania. Cały przykład to 80 linii kodu, z czego ponad połowa to puste linie i komentarze.

Zarządzanie danymi tabelarycznymi za pomocą dhtmlxGrid

2009-12-12T11:24:45+00:00

Prosta aplikacja Django zarządzająca danymi tabelarycznymi za pomocą grida dhtmlxGrid stworzonego przez DHTML eXtensions. #django, #javascript, #grid, #xgrid, #dhtmlx

Licznik aktywnych użytkowników: txActiveUsersCounter

2009-12-09T20:57:03+00:00

Ponieważ niedługo będzie mi prawdopodobnie potrzebny licznik "aktywnych" użytkowników na stronie, napisałem szybką implementację opartą na samodzielnym serwerze napisanym w twisted oraz pluginie jQuery. Projekt dostępny jest na github pod nazwą txActiveUsersCounter.

Algorytm zliczania jest bardzo prosty. Każdy użytkownik posiada unikalny id generowany na podstawie aktualnej daty i losowej liczby, który przechowuje w ciastkach. Przy pobieraniu informacji o ilości osób na stronie, przesyła w requeście swój id i opcjonalnie nazwę grupy. Serwer, jeśli jeszcze nie ma takiego id na liście, zapisuje go na N sekund, po których wygaśnie. W odpowiedzi, zawracana jest liczba id dla wybranej grupy.

To co sprawiło mi najwięcej problemu to znalezienie informacji jak działa jsonp, dzięki któremu możliwe jest wykonywanie cross domain xhr . Czytając różne przykłady doszedłem do tego, że używając jQuery wystarczy aby w url zawarty był parametr ze znakiem ? zamiast wartości, który zastąpiony zostanie przez jsonp<numer>, którym serwer musi opakować zwracany obiekt json.

Przykład: klient wykonuje funkcję $.get podając jako jeden z argumentów adres http://localhost/?a=1&crossjson=?, który w efekcie zostanie zamieniony na http://localhost/?a=1&crossjson=jsonp123. Serwer po odebraniu takiego requesta zwraca obiekt json opakowany wartością znajdującą się pod kluczem crossjson, czyli na przykład jsonp123({'random': 4}).

Scala - język przyszłości

2009-12-06T01:42:56+00:00

Kiedy zapytano Jamesa Goslinga (twórcę Javy) o to, który z języków programowania współpracujących z JVM (wirtualną maszyną Javy) by użył teraz, pomijając samą Javę, odpowiedź była zaskakująco szybka i bardzo jasna – Scala.

Nazwa “Scala” pochodzi od “Scalable language” (język skalowalny). Język ten nadaje się równie dobrze do krótkich, zwartych skryptów jak i do tworzenia wydajnych, ogromnych, bezpiecznych systemów sieciowych. W swych założeniach Scala nawiązuje do minimalizmu składni Lispa i Smalltalka (większość rzeczy oparta jest na bibliotekach a nie na składni) dzięki czemu język ten praktycznie nie ma ograniczeń rozwoju i doskonale się skaluje (w miarę potrzeb można tworzyć nowe typy i całe nowe struktury wyglądające jak nowa składnia języka).

Scala jest językiem kompilowanym do bytecodu JVM dzięki czemu potrafi się integrować w sposób praktycznie przezroczysty, z całą platformą Javy (istnieje co prawda implementacja Scali dla platformy .NET ale jest jeszcze niedojrzała). W Scali mamy też wygodną konsolę do interaktywnego testowania kodu (tak jak to jest w Pythonie i Ruby). W Scali każda wartość jest obiektem, każda funkcja zwraca wartość. Zatem każda funkcja też jest obiektem (first class object). Funkcje są też obiektami wyższego rzędu (higher order kinds), można je zagnieżdżać, przekazywać w parametrach, a nawet stosować mechanizm dziedziczenia.

Java jako platforma i jako język

Słowo “Java” oznacza z jednej strony język programowania, z drugiej platformę JVM. Sam język Java jest co prawda prosty, ale też dosyć toporny. Nic dziwnego, że pada wiele słów krytyki pod jego adresem. Co innego platforma Javy. JVM jest dopracowana, stabilna i szybka (ze swoim HotSpotem potrafi pobić kod napisany w języku C). Biblioteki są dojrzałe i używane masowo w biznesie i instytucjach finansowych. Każda nowość błyskawicznie znajduje swoje odzwierciedleniew Javie (ilość projektów w Javie wielokrotnie przewyższa to, co jest dostępne dla platformy .NET). Platforma Javy mocno prze do przodu i zwiększa stale swoją pozycję. Wydaje się tylko, że sam język nie za bardzo nadąża za tymi zmianami.

Gdy Microsoft “wyskoczył” ze swoją koncepcją .NET umożliwiającą tworzenie aplikacji na tą platformę w kilku językach a nie “jedynym prawidłowym”, można było odebrać to jako prztyczek w nos dla starej doktryny lansowanej kiedyś w środowisku Javy (jako jednego języka do wszystkiego). W rzeczy samej, patrząc dziś, Microsoft ze swymi językami zgodnymi z CLR niczym specjalnym nie zachwyca. Po pierwsze, istnieje dziś już ok. 240 różnych języków zgodnych z platformą Javy (jakieś 5x tyle co dla CLR). Javowe implementacje powstały nawet do języków dynamicznie typowanych (Groovy) oraz takich jak Python (Jython), Ruby (JRuby), JavaScript (Rhino) czy PHP (Quercus).

Po drugie, w przeciwieństwie do .NET, Java jest prawdziwie multiplatformowa (istnieje co prawda projekt Mono, ale wciąż odstaje jakością od windowsowego .NET). Mówiąc krótko, platforma Javy trzyma się mocno. Ale sam język jest przestarzały i wszyscy się zastanawiają nad tym, co by mogło go zastąpić. Moim zdaniem, coraz więcej wskazuje, że tym językiem może być Scala. (Swoją drogą język Java tak całkiem to pewnie nigdy nie zniknie. Raczej zredukuje się do miana assemblera XXI wieku. Zresztą już dziś tak wielu myśli o Javie, jako o assemblerze dla JVM)

Scala jako pure OOP

Scala jest językiem obiektowym w stopniu większym niż Java. W Scali nie ma sztucznego podziału na obiekty i typy prymitywne (int, float, string). Każda wartość jest w Scali pełnym obiektem (choć pod spodem kompilator Scali, tam gdzie się da, sam dokonuje inteligentnych konwersji na javowe prymitywy).

Każdy operator jest też metodą. Np. zapis 1 + 2 odpowiada dokładnie temu samemu co (1).+(2). Innymi słowy obiekt “1” używa tu metody ”+” operującej na parametrze będącym obiektem “2”. A to, że można opuścić nawiasy związane jest z tzw. notacją operatorową jaka jest możliwa Scali. O ile Ruby pozwala opuszczać nawiasy w niektórych sytuacjach (w definicji i wywołaniu metody), to Scala pozwala na opuszczanie ich w wypadku każdej metody pomiędzy dwoma wyrażeniami. W efekcie Scala pozwala na pisanie testów BDD przypomijących jeszcze bardziej język naturalny niż RSpec do Ruby’ego (też scalaz, scalatest). Także tworzenie nowych języków specjalnego zastosowania, tzw. DSL’i, dzięki notacji operatorowej wyglądają w Scali ładniej niż w Ruby. W ramach żartu pokazującego elastyczność składni Scali napisano nawet interpreter języka BASIC.

W Scali, w przeciwieństwie do Javy, nie ma też statycznych metod ani zmiennych (żałosne jest to, że tak nieobiektowe konstrukcje w ogóle wprowadzono do PHP). Zamiast nich Scala używa singletonów i metod klasowych. Oczywistą przewagą takiego podejścia jest m.in. możliwość dziedziczenia.

Podczas gdy Ruby i Python trzymają definicje metod klasowych i instancji razem, Scala trzyma je zgrupowane oddzielnie.

# Python:
class C(Object):
    def metoda_instancji(self):
        return "Jestem metodą instancji" 
    @classmethod
    def metoda_klasowa(cls):
        return "Jestem metodą klasową" 
print C.metoda_klasowa()
print C().metoda_instancji

# Ruby:
class C
  def self.metoda_klasowa
    "Jestem metodą klasową" 
  end
  def metoda_instancji
    "Jestem metodą instancji" 
  end                       
end
puts C.metoda_klasowa
puts C.new.metoda_instancji

# Scala
class C {
  def metoda_instancji = 
    "Jestem metodą instancji"    
}          
object C {
  def metoda_klasowa = 
    "Jestem metodą klasową" 
} 
println((new C).metoda_instancji)
println(C.metoda_klasowa)

Scala jako język statycznie typowany z inteligentną inferencją typów

Scala jest językiem statycznie typowanym. Z pewnością ucieszy to tych, co nie chcą pisać tony dodatkowych testów jednostkowych. Statyczna kontrola typów zapewnia większą kontrolę nad kodem. Można się zdziwić, jakim cudem przedstawiony wyżej kod działa, skoro nie ma w nim żadnej deklaracji typów. Właściwie to powyższa deklaracja klas i singletonu formalnie wygląda tak

class C {
  def metoda_instancji(): String = 
    return "Jestem metodą instancji";
}          
object C {
  def metoda_klasowa(): String = 
    return "Jestem metodą klasową";
}

Jednak nie trzeba pisać tak rozwleklego kodu. Scala posiada wyrafinowany mechanizm inferencji typów pozwalający na ograniczenie niepotrzebnego deklarowania typów w wypadkach kiedy kompilator jest w stanie to sobie samemu wywnioskować (podobną inferencję typów stosują inne języki, np. Haskell).

W Scali także (podobnie jak w Ruby czy JavaScript) końcowe średniki zamykające wyrażenie można pominąć, nawiasy dla metod bez parametrowych są opcjonalne i nie trzeba używać komendy return aby zwrócić wartość z metody. W Scali (podobnie jak w Ruby) zawsze zwracana jest ostatnia wartość wyrażenia.

Scala, podobnie jak Java i Ruby, nie posiada dziedziczenia wielobazowego. W przeciwieństwie do Javy, Scala nie posiada interfejsów. I bardzo dobrze, bo ich przydatność jest wysoce wątpliwa (oczywiście do PHP5 dodano bezmyślnie te nieszczęsne interfejsy). Ich główną wadą jest to, że nie mogą posiadać żadnej implementacji ani deklaracji zmiennych. Z kolei klasy abstrakcyjne w Javie mogą posiadać częściową implementację, ale nie można dziedziczyć po wielu klasach abstrakcyjnych tylko po interfejsach które nie mają żadnej implementacji. Bardzo niewygodne. Scala rozwiązuje ten problem za pomocą traits. Traits działają podobnie do modułów w Ruby. Nie mają konstruktorow ani nie można stworzyć ich instancji więc odpada efekt konfliktu kolejności konstruktorów. Traits mogą jednak podlegać dziedziczeniu, mogą mieć częściową lub pełną implementację metod, oraz mogą posiadać zadeklarowane zmienne. I każda klasa może dziedziczyć po kilku traitsach. Proste i wygodne.

Niejawne konwersje (implicit conversion)

Idea niejawnych konwersji nie jest w zasadzie niczym nowa. Występuje już w języku C. Gdy dodawane są dwie zmienne o typach short i long to ta pierwsza zostaje domyślnie przekształcona do long. Nie trzeba wykonywać żadnego jawnego rzutowania typu.

Scala idzie dalej. Za pomocą mechanizmu implicit conversions potrafi uzyskać efekty podobne jak w Ruby, ale bardziej bezpieczne. Zobaczmy jednak wpierw jak to się robi Ruby (który wykorzystuje swoją koncepcję otwartych klas).

class Integer
  def kb
    self * 1024
  end     
  def mb
    self * 1024 * kb
  end  
end                   

class String 
  def welcome
    "Hello " + self
  end
end

puts 10.kb # => 10240
puts 10.mb # => 10485760
puts "Jarek".welcome # => Hello Jarek

Co prawda Ruby potrafi “zamrozić” swoje obiekty uniemożliwiając ich modyfikację

Fixnum.freeze

class Integer
  def kb
    self * 1024
  end
end   
# => TypeError: can't modify frozen class

ale technika ta (zwana też trochę niepoprawnie jako “monkey patching”) jest używana dosyć powszechnie w Ruby. Główną jej wadą jest to, że takie zmiany w klasach są globalne i to może prowadzić do różnych nieporozumień w innych częściach kodu.

Scala nie ma tego problemu. Pozwala na uzyskanie podobnych efektów bez konieczności globalnych zmian w obiekcie. Zamiast otwierania klas, Scala dodaje definicje niejawnych konwersji. Jeśli wywołujemy metodę obiektu której on nie posiada, Scala patrzy na leksykalny kontekst definicji dostępnych konwersji dla danego typu (jak pamietamy, Scala jest językiem statycznie typowanym). Jeśli znajdzie sygnaturę metody taką jak nazwa wywoływanej metody, użyje jej tak jakby należała do obiektu.

class StrConvert(s: String) {
  def welcome = "Hello " + s
}                         

class IntConvert(x: Int) {
   def kb = 1024 * x
   def mb = x * 1024 * kb
}                    

implicit def str_convert(s: String) =  new StrConvert(s)
implicit def int_convert(i: Int) =  new IntConvert(i)

println(10.kb)
println(2 mb)
println("Jarek" welcome)

Kropki w wywołaniach metod są oczywiście w Scali opcjonalne ze względu na notację operatorową.

Niejawne konwersje Scali przydają się w wypadku korzystania z cudzego kodu. Nie musimy (tak jak w Ruby) ingerować i zmieniać cudzych bibliotek. Zamiast tego wystarczy dodać lokalne definicje niejawnych konwersji typów. Przykładem toporności i ograniczeń Javy jest konieczność korzystania z innej składni do operacji na typach BigInteger. Jeśli początkowo pisaliśmy kod używający zwykłych typów int to w wypadku kiedy musi on operować na większych liczbach, czeka nas niezła refaktoryzacja kodu a kod mógłby wyglądać mniej więcej tak jak poniższy kod (przykład dotyczy składni Scali w ktorej też można pisać po “javowemu”)

                        
import java.math.BigInteger 

def factorial(x: BigInteger): BigInteger = 
 if (x == BigInteger.ZERO) 
   BigInteger.ONE 
 else 
   x.multiply(factorial(x.subtract(BigInteger.ONE)))

Dzięki możliwościom implicit conversion, znacznie wygodniej jest pisać tak:

def factorial(x: BigInt): BigInt = 
 if (x == 0) 1 else x * factorial(x - 1)

Warto zwrócić uwagę, że to nie jest jakaś dodana nowa składnia do Scali. Wrapper do BigInt jest stworzony w bibliotece. Nie trzeba żadnego przebudowania kodu Scali tak, jak to musi być uczynione w innych językach.

Scala jako język funkcyjny (FP)

Mam wrażenie, że programowanie funkcyjne przeżywa jakiś swój renesans. Od jakiegoś czasu więcej słychać o Erlangu, Clojure (świetny dialekt Lispa w Javie), Haskellu czy F#. Zalety programania funkcyjnego w stosunku do programowania imperatywnego są znane. Przede wszystkim, brak zmiennych i brak efektów ubocznych. Odpadają problemy związane z synchronizacją wątków, semaforami i blokowaniem dostępu do wspólnych obszarów pamięci. Kod pisany funkcyjnie znacznie łatwiej jest też testować. Funkcja niczym ma tylko jedno wejście i jedno wyjście. Nic innego ukradkiem nie zmieni. Programowanie funkcyjne jest też prostsze, choć osoby spaczone latami spędzonymi na programowaniu imperatywnym, mogą mieć na początku pewne problemy z przestawieniem sposobu myślenia. Np. w typowo funkcyjnym podejściu nie ma w ogóle pętli w programie. Zastępuje ją rekursja (która nie przepełnia stosu, jest to tzw. tail recursion)

Przykład różnic w podejściu imperatywnym oraz funkcyjnego dla Ruby’ego i Scali.

Ruby:

# Podejście imperatywne:

class Imper
  attr_accessor :x, :y
  def initialize(x,y)
    @x, @y = x, y
  end     
  def move_by(dx, dy)
    @x += dx
    @y += dy
  end
  def show
    puts "x:#{x}, y:#{y}" 
  end
end                                                                

x = Imper.new(1,2)
x.move_by(3,4)
x.show

# To samo funkcyjnie:

class Func
  attr_reader :x, :y
  def initialize(x,y)
    @x, @y = x, y
  end     
  def move_by(dx, dy)
    Func.new(@x+dx, @y+dy)
  end
  def show
    puts "x:#{x}, y:#{y}" 
  end
end

x = Func.new(1,2)
x = x.move_by(3,4)
x.show        

# lub to samo, ale bez tworzenie zmiennych:

Func.new(1,2).move_by(3,4).show

Scala:

                          
// Kod w stylu imperatywnym:

class Imper(x: Int, y: Int) {
  var iks: Int = x
  var igrek: Int = y           
  def move_by(dx: Int, dy: Int) {
    iks += dx
    igrek += dy
  }
  def show {
    println(iks,igrek)
  }
}                 
val p = new Imper(1,2)
p.move_by(3,4)
p.show

// i to samo funkcyjnie:

class Func(x: Int, y: Int) {
  val iks: Int = x
  val igrek: Int = y           
  def move_by(dx: Int, dy: Int) = new Func(iks+dx, igrek+dy)
  def show {
    println(iks,igrek)
  }
}                 
(new Func(1,2)).move_by(3,4).show

Obiekty deklarowane jako val są niemutowalne, nie można zmienić ich wartości (odpowiadają javowej deklaracji final). Z kolei deklaracja var oznacza zmienne mutowalne, mogące zmienić swoją wartość.

Kod pisany funkcyjnie, może być znacznie krótszy, prostszy i tym samym mniej podatny na błędy. Zobaczmy, jak bardzo można zredukować w Scali kod napisany w stylu imperatywnym do funkcyjnego (przykład z książki “Programming in Scala”)

                          
def printArgs(args: Array[String]): Unit = { 
  var i = 0 
  while (i < args.length) { 
    println(args(i)) 
    i += 1 
  } 
}

Pozbywamy się zmiennej var:

                          
def printArgs(args: Array[String]): Unit = { 
  for (arg <- args) 
    println(arg) 
}

To samo, inaczej wyrażone:

                          
def printArgs(args: Array[String]): Unit = { 
  args.foreach(println) 
}

Metoda nie jest jeszcze “czysto” funkcyjna bo posiada efekt uboczny w postaci drukowania wartości w funkcji println. Pozbywamy się więc i jej.

                          
def formatArgs(args: Array[String]) = args.mkString("\n")

Wywołanie:

                          
println(formatArgs(args))

Warunki zwracające wynik

W Scali warunki logiczne także zwracają wartość. Weźmy na przykład kwestię operatora trynarnego. W wielu językach można spotkać (odziedziczoną po C) następującą składnię:

                          
wynik = warunek ? wyrazenie1 : wyrazenie2

Przez wiele lat w Pythonie trzeba było pisać w taki sposób:

                          
if warunek:
    wynik = wyrazenie1
else:
    wynik = wyrazenie2

Pod naciskiem społeczności, Guido van Rossum dodał w końcu odpowiednik takiej konstrukcji i teraz można pisać tak:

                          
wynik = wyrazenie1 if warunek else wyrazenie2

Tymczasem w Scali taki problem jest zupełnie sztuczny. Skoro warunek zwraca wynik, to nie trzeba wymyślać żadnej nowej składni naśladującej język C. Wystarczy po prostu napisać:

                          
val wynik = if (warunek) wyrazenie1 else wyrazenie2

Ogólnie, cała Scala promuje podejście funkcyjne, ale nie zmusza do niego. Scala nie stosuje oddzielnych nazw dla wersji mutowalnej i niemutowalnej. Dzięki temu unika się niepotrzebnego refactoringu kodu w wypadku potrzeby zmiany jednej wersji na drugą.

Domyślnie typy są niemutowalne.

                          
scala> val x = Map[Int, String]() 
# => x: scala.collection.immutable.Map[Int,String] = Map()

Aby mieć tym mutowalny, trzeba to jawnie wskazać.

                          
scala> import scala.collection.mutable.Map
scala> val x = Map[Int, String]()         
# => x: scala.collection.mutable.Map[Int,String] = Map()

Lift – komponentowy framework w Scali

Mówiąc o Scali nie sposób nie wspomnieć o świetnym frameworku webowym jakim jest Lift. Framework ten inspirowany jest różnymi frameworkami (głównie Wicket’em ale też Django, Rails czy smalltalkowym Seaside). Lift jest przede wszystkim frameworkiem komponentowym (odcina się tu od klasycznego modelu MVC promowanego przez Rails). Podejście komponentowe ma przewagę nad MVC, dużo lepiej się nadaje do złożonych aplikacji (innym przykładem dobrego podejścia komponentowego jest pythonowy CMS – Plone.

Lift Book – darmowa, dostępna online (najnowsza wersja PDF jest na dole strony: http://groups.google.com/group/the-lift-book)
Exploring Lift: Scala-based Web Framework – książka (dostępna jeszcze w wersji roboczej)
David Pollak On Lift Framework and Scala
Derek Wischusen on Integrating Flex, BlazeDS and Scala/Lift

Inne frameworki:

Podsumowując.

Scala to nowoczesny język będący hybrydą pure OOP i FP, statycznie typowany ale z inteligentną inferencją typów, o bardzo elastycznej składni i kompilowana do bytecodu JVM. Dzięki zaawansowanej inferencji typów i implicit conversions nie odczuwa się narzutu związanego z faktem że Scala jest statycznie typowana (a dostaje zalety ściślejszej kontroli kodu). Scala nie ma operatorów, operatory są zwykłymi metodami definiowanymi w bibliotekach.

Jednak tym co jest największym atutem Scali to jej minimalizm składniowy. Scala umożliwia tworzenie nowych typów i struktur językowych bez konieczności zmian w samej zasadniczej składni języka. To oznacza, źe podobnie jak Lisp, Scala nie ma praktycznie żadnych ograniczeń w rozwoju. Tym samym Scala jest w stanie przetrwać różne tendencje i upodobania składniowe i “przeskalować” się do nowych potrzeb.

Scalę używa już gdzieś parę banków w UK. Na Scalę niedawno przeszedł Twitter, ma wkrótce przejść też Github.

Linki

Python 2.7 alpha 1

2009-12-05T21:55:49+00:00

Benjamin Peterson ogłosił na grupie dyskusyjnej python-dev wydanie pierwszej wersji alfa Pythona 2.7. Jest to ostatnia zaplanowana wersja z linii 2.x. W wydaniu tym znajdziemy wiele elementów, które ukazały się w Pythonie 3.1, między innymi: - szybszy moduł io - słownik pamiętający kolejność dodawania elementów PEP372 - nowa składnia dla zagnieżdżonego with Pełna lista zmian jak zwykle znajduje się na stronie "Whats New" w dokumentacji Pythona 2.7. Celem wydania Pythona 2.7 poza przeportowaniem ważniejszych zmian z 3.x jest ułatwienie migracji właśnie do Pythona 3.x, ułatwić to ma rozwijany skrypt py2to3, który automatycznie zmienia składnie na zgodną z trójką. Innym elementem jest dodanie kolejnych ostrzeżeń przy uruchamiania pythona z flaga -3, dzięki czemu można pisać kod, który będzie prostszy do portowania. Jak zwykle zachęcamy do testowania i zgłaszania błędów na stornie: bugs.python.org Pobierz: Python 2.7 Źródło: python.org

Wdrożenie Django na michaelmoore.com

2009-11-28T13:10:34+00:00

Opis wdrożenia Django i powiązanych technologii na nowej wersji serwisu michaelmoore.com

Migracja Mozilla Addons na Django

2009-11-28T12:46:08+00:00

Streszczenie wpisu na blogu All Night Diner zawierającego powody i zalety zastąpienia CakePHP przez Django dla serwisu Mozilla Addons.

Prosta aplikacja Django prezentująca dane z PyEphem

2009-11-28T11:58:13+00:00

Tworzymy prostą aplikację Django wyświetlającą dane generowane przez PyEphem przydatne przy obserwacji planet i Księżyca

PyDev 1.5.1

2009-11-21T12:23:13+00:00

Pomimo opóźnień spowodowanych pewnymi zmianami w silniku refaktoryzacji pluginu oraz kilkoma mniejszymi problemami, wydano w końcu nową wersję PyDev - 1.5.1. Przygotowując poprzednią wersję, skupiono się przede wszystkim na zwiększeniu komfortu programisty poprzez m.in.: włączenie kodu PyDev extensions do projektu PyDev czy dodanie wsparcia dla IronPython. W najnowszej wersji natomiast, developerzy, oprócz rutynowego debugowania, udoskonalili rewriter AST oraz silnik refaktoryzacji pluginu. Zmiany zaszłe w silniku refaktoryzacji, to m.in.: rezygnacja z BRM, włączenie kodu najnowszego wydania PEPTIC do projektu, dodanie opcji dodaj po bieżącej metodzie do metody wydobywania, możliwość generowania właściwości przy użyciu stylu programowania zdefiniowanego w preferencjach. Z poprawionych błędów wymienić można: drobne poprawki edytora, naprawienie prawidłowego wykorzystywania znaku Backspace w trybie blokowym, ustawianie IRONPYTHONPATH podczas korzystania z IronPythona (projekty nie mogą odwoływać się do siebie), używanie funkcji exec w Py3k, usunięcie problemu z importowaniem modułu regexp, który mógł wywołać rekurencję; Fabio Zadrozny oznajmił, że podczas prac nad następnymi wersjami PyDev, developerzy bardziej skupią się na wykrywaniu i naprawianiu błędów oraz stworzeniu sesji profilujących (odpowiedzialnych za prędkość i wykorzystanie pamięci). Źródło: PyDev

Ferie zimowe z Pythonem

2009-11-17T23:46:55+00:00

Jeżeli nie macie jeszcze planów na spędzenie noworocznych ferii zimowych, to zachęcam Was do wzięcia udziału w kolejnym bezpłatnym obozie Advanced Scientific Programming In Python. Odbędzie się on w dniach 8-12 lutego 2010, na Wydziale Fizyki Uniwersytetu Warszawskiego. Organizatorami imprezy są G-Node (German Neuroinformatics Node) i FUW. Obóz kierowany jest do osób, które na co dzień zajmują się tworzeniem symulacji naukowych oraz analizą danych. W czasie jego trwania zostanie przedstawiony wybór zaawansowanych technik programowania w Pythonie, na podstawie teoretycznych wykładów i ćwiczeń praktycznych. Aby wziąć udział w tej imprezie, należy do dnia 6 grudnia zgłosić swój profil, zawierający pełne dane kontaktowe, CV i odpowiedzi do poniższych pytań: What is your educational background? What experience do you have in programming? Why do you think Advanced Scientific Programming in Python is an appropriate course for your skill profile? Zgłoszenia wysyłamy na: python-winterschool@g-node.org W związku z tym, że ilość miejsc jest ograniczona, zostanie przeprowadzona selekcja profili. Status zakwalifikowania będzie znany już 14 grudnia, powiadomienia zostaną rozesłane drogą e-mailową. W celu pozyskania większej ilości informacji, typu agenda, dojazd na miejsce czy proponowane zakwaterowanie, zapraszam do odwiedzin strony głównej obozu.

PyEphem - obliczenia astronomiczne dla Układu Słonecznego

2009-11-14T15:32:26+00:00

Wyliczamy położenie, konstelację i inne dane obiektów Układu Słonecznego (planety, księżyce) oraz jasnych gwiazd z poziomu Pythona. #python, #astronomia

Obsługa silnika JavaScript w Pythonie za pomocą python-spidermonkey

2009-11-14T14:39:55+00:00

Moduł python-spidermonkey udostępnia API na niezależny silnik JavaScript SpiderMonkey, co umożliwia wykonywanie kodu JavaScript w skryptach Pythona #python, #javascript, #spidermonkey

PEP 3003 - Python zamrożony na najbliższe lata

2009-11-10T22:00:40+00:00

W październiku Guido van Rossum zaproponował ustanowienie moratorium, na dalsze zmiany w syntaktyce i semantyce języka. Za zgodą społeczności, plan udało się wcielić w życie. Efektem jest PEP 3003 ogłaszający czasowe zawieszenie wszelkich zmian w języku, na okres przynajmniej dwóch lat od wydania Pythona 3.1. A to znaczy, że objęty tym zostanie jeszcze Python 3.2, a nowe elementy języka będą mogły zostać wprowadzone najwcześniej w wydaniu 3.3. Wg. autorów ww. PEP'a, Bretta Cannona, Jesse'a Nollera, Guido van Rossuma, pozwoli to twórcom alternatywnych implementacji Pythona nadążać za rdzenną implementacją języka oraz ułatwi akceptację serii 3.x i stworzenie "stabilniejszej bazy dla społeczności". Po dłuższej debacie, uznano że wszelkie wprowadzane obecnie zmiany nie znalazłyby uznania wśród użytkowników. Powodem tego jest najczęściej ograniczenie w postaci udostępniania starszej wersji interpretera, nakładana przez dostawców hostingu. Większość dostawców nadal oferuje wydania z gałęzi 2.x, podczas gdy gałąź 3.x jest zazwyczaj uznawana za niestabilną i zbyt młodą, aby używać jej na serwerach. Moratorium nie dotyczy C API, które można nadal modyfikować pod warunkiem nienaruszania spójności standardowej implementacji Pythona (CPython). Okres obowiązywania moratorium może zostać przedłużony tylko poprzez nowy PEP. Źródło: Python Enhancement Proposal 3003

Wykorzystanie WebKit/PyQt4 do zbierania danych, część 3

2009-11-08T08:25:23+00:00

Tworzymy aplikację pobierającą finalne dane o reklamach zapisanych w bazie danych z wykorzystaniem QtWebKit #python, #pyqt, #pyqt4, #reklama

Obsługa usług Google za pomocą xgoogle

2009-11-06T10:17:46+00:00

Moduł xgoogle umożliwia wyszukiwanie dla podanej frazy, w tym także wyszukiwanie linków płatnych. Obsługuje także Google Sets i Google Translator. #python, #google, #translator, #seo

Wykorzystanie WebKit/PyQt4 do zbierania danych, część 2

2009-11-02T17:55:32+00:00

Wyciąganie odnośników reklam z kodu stron, zapisywanie danych w bazie za pomocą QtSql #python, #pyqt, #pyqt4, #adtaily

Wykorzystanie WebKit/PyQt4 do zbierania danych, część 1

2009-10-31T09:59:21+00:00

Wykorzystanie QtWebKit do stworzenia aplikacji zbierającej dane o reklamach dostępnych na wskazanych serwisach #python, #pyqt, #pyqt4, #reklama

Pogoda w Pythonie

2009-10-28T15:46:29+00:00

Pobieramy prognozy pogody Yahoo i Google z poziomu Pythona za pomocą biblioteki python-weather-api.

Python 2.6.4

2009-10-27T13:40:47+00:00

Już od dwóch dni, dostępna do pobrania jest finalna wersja Pythona z gałęzi 2.6 - 2.6.4. Jest to wyczekiwany od miesiąca bugfix wersji 2.6.3. Podobnie jak w wydaniach 2.6.4rc1 oraz 2.6.4rc2, nie wprowadzono żadnych znaczących zmian - jedynym celem developerów było naprawienie błędów w pakiecie logowania oraz problemu kompatybilności narzędzi setuptools. Gotowe do pobrania paczki aktualnego wydania, znajdziemy w sekcji DOWNLOAD na oficjalnej stronie projektu. Źródło: python.org

Guido van Rossum proponuje moratorium na dalsze zmiany w języku

2009-10-23T21:39:10+00:00

Przez ostatnie kilkanaście lat Python przeszedł wiele, często znaczących dla dalszego rozwoju projektu, zmian. Niestety, część z nich oprócz udogodnień wprowadziła także zjawisko niekompatybilności wstecznej (mowa tu o Pythonie w wersji 3.x), co dało się we znaki wielu developerom i twórcom alternatywnych implementacji języka. Sprawa została uznana za poważną, gdyż nawet sam twórca języka - GvR - jest za odrzuceniem tych praktyk. W tym celu chce ustanowienia moratorium na dalsze zmiany w syntaktyce i semantyce języka, oraz skupienia się na popularyzacji standardu Python 3000. Problem został poruszony na liście mailingowej, a jego słuszność poparta takimi argumentami, jak choćby nie wnoszenie praktycznie żadnych korzyści dla przeciętnych użytkowników, lub utrudnianie pracy twórcom alternatywnych implementacji, takich jak: IronPython, Jython lub PyPy. Dlatego też, BDFL namawia społeczność rozwijającą Pythona aby odpuściła ciągłe wprowadzanie zmian i skupiła się na pracy nad właściwym rozwojem standardu Py3k. Wśród rzeczy do zrobienia, wyróżnić można przeniesienie zewnętrznych bibliotek do wersji 3.x, napisanie narzędzi pomocnych w tym procesie oraz w utrzymaniu wielu wersji kodu aplikacji, czy wreszcie spisanie całego procesu przenoszenia w formie dokumentacji. Moratorium na dalsze zmiany dotyczyć ma wyłącznie samego języka i funkcji wbudowanych, bez biblioteki standardowej. Wg. Guido, prace nad rozwojem standardowej biblioteki, mimo że bardzo ważne, nie powinny zakłócać procesu rozwoju alternatywnych implementacji. Dobrym pomysłem jest także ciągłe wprowadzanie zmian w C API a nawet propozycja pozbycia się GIL. Wśród jednej z uwag, było przypomnienie o konieczności wprowadzenia obsługi przetwarzania równoległego i wykonywania wielowątkowego kodu. Generalnie, zaobserwować można same pozytywne opinie od strony postaci ze społeczności skupionej wokół rozwoju Pythona, implementacji alternatywnych lub popularnych aplikacji stworzonych w Pythonie. Źródło: python-ideas@mail.python.org

Twisted - wprowadzenie: generatory

2009-10-19T20:45:05+00:00

We wpisie "reactor i deferred" przedstawiłem koncepcje programowania asynchronicznego z wykorzystaniem obiektu Deferred w którym kolejkowane były zadania. Taki sposób pisania może być jednak bardzo niewygodny, jeśli okaże się, że w swoim kodzie mamy wiele miejsc oczekujących na dane. Każdorazowe pojawienie się nowych informacji wymaga napisania nowej funkcji która je obsłuży. Drugie tyle, jeśli chcemy oprogramować możliwe wystąpienia błędów.

Generatory

Jaki jest generator, każdy widzi. Najprostszym przykładem może być generowanie kolejnych liczb:

>>> def gen_number(start):
...     while True:
...         start += 1
...         yield start
...         
>>> g = gen_number(2)
>>> g.next()
3
>>> g.next()
4
>>> g.next()
5

Jeśli chcesz dowiedzieć się o nich więcej, polecam prezentację "Generator Tricks for Systems Programmers".

Generatory, aż do Pythona 2.5 miały bardzo poważną wadę - były hermetyczne. Utworzony obiekt nie przyjmował żadnych danych z zewnątrz i mógł jedynie zwracać kolejne wartości. Od wersji 2.5, generatory posiadają metodę send(), dzięki któremu komunikacja odbywać się może w obu kierunkach:

>>> def push_filter(power):
...     #initialize for future usage
...     data = 0
...     while True:
...         data = yield (data ** power)
...         
>>> pf = push_filter(3)
>>> # initialize generator
>>> pf.next()
0
>>> pf.send(3)
27
>>> pf.send(4)
64
>>> pf.send(2)
8

Nieocenioną pomocą w zrozumieniu nowych możliwości generatorów był dla mnie wykład "A Curious Course on Coroutines and Concurrency". Kolejno omawiane w nim przykłady to implementacja "systemu operacyjnego" ze wsparciem dla zielonych wątków. Końcowy kod rozbudowałem o dodatkowe sygnały i epoll. W efekcie otrzymałem asynchroniczny prawie-framework. Jego główna zaletą jest wykorzystanie yield do oczekiwania na blokujące operacje, dzięki czemu nie muszę pisać callbacków. Pierwszy z trzech przykładowych programów to serwer echo:

# importy...

def handle_request(sock, addr):
    data = ''
    while True:
        data += yield sock.recv(1024)
        if '\r\n' in data:
            break
    response = 'echo: ' + data
    yield sock.send(response)
    yield sock.close()

def echo(raw_socket, host, port):
    sock = Socket(raw_socket)
    sock.bind((host, port))
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.listen(1)
    while True:
        print '>> waiting for new connection'
        conn, addr = yield sock.accept()
        # spawn new light-thread task
        yield calls.NewTask(handle_request(conn, addr))

scheduler = Scheduler()
raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
scheduler.add(echo(raw_socket, '', 8080)
scheduler.run()

Każda blokująca operacja opakowana jest przez sygnał systemowy , przez co możliwe jest użycie yield i uśpienie podprogramu aż do nadejścia danych. W kolejnych przykładach pokazałem, jak proste jest używanie wyjątków.

Twisted już to ma..

Ostatnim przykładem jaki napisałem w twisted był serwer pobierający strony. W metodzie lineReceived tworzony był obiekt Deferred w którym kolejkowane były send_sucess oraz send_errback. Przykład wyglądał nie najgorzej, bo wymagał jedynie dwóch callbacków. Co jeśli każde żądanie klienta wymagałoby X blokujących wywołań? Musiałbym napisać co najmniej 2X funkcji?

W module twisted.internet.defer znajduje się dekorator inlineCallbacks, który pozwala na wykorzystanie możliwości generatorów Pythona >= 2.5. Ten sam przykład może więc wyglądać o wiele lepiej:

def lineReceived(self, line):
    self._lineReceived(line)

@defer.inlineCallbacks
def _lineReceived(self, line):
    try:
        page = yield getPage(line)
    except Exception as e:
        self.sendLine('%s:%s' % \
                (type(e).__name__, ', '.join(e.args)))
        self.transport.loseConnection()
    else:
        data = page.replace('\r\n', '')
        self.sendLine(data)

Udostępnianie Fal na stronach internetowych

2009-10-19T18:08:59+00:00

Przepis na publikowanie Fal z Google Wave na zewnętrznych stronach internetowych za pomocą robota embeddy i wklejki JavaScript. #python, #googlewave, #wave

Tworzenie interfejsów graficznych w QtDesigner dla aplikacji PyQt4

2009-10-19T14:53:59+00:00

Przewodnik przedstawiający możliwości, proces tworzenia i wykańczania interfejsu użytkownika w graficznym edytorze QtDesigner #python, #pyqt, #pyqt4, #gui, #desktop

PyconPL 2009

2009-10-19T09:02:39+00:00

No, byłem. Co do konferencji jako takiej to wolę się nie wypowiadać, ale wnioskuję, że nie byłem jej targetem — był może jeden wykład, na którym dowiedziałem się czegoś nowego i jeden, który obejrzałem dla przyjemności. Aspekt społeczny w pewnym stopniu został zaspokojony przez bratanie się z kolegami z Allegro.pl ...

RkTaggy - przykładowy robot Google Wave

2009-10-17T17:11:58+00:00

Opis i implementacja przykładowego robota w Pythonie dla Google Wave wraz z kodem źródłowym. Wskazówki pomocne przy tworzeniu nowych robotów. #python, #wave, #googlewave, #google, #gae

Zastosowanie protokołu OAuth w aplikacjach Django/Python

2009-10-17T09:56:19+00:00

Opis protokołu OAuth, dostępnych bibliotek oraz przykładowej aplikacji Django django-twitterauth umożliwiającej obsługę Twittera poprzez ten protokół. #python, #oauth

Czas na Pythonowe screencasty

2009-10-16T16:24:17+00:00

Planuję stworzenie kilku/nastu screencastów dotyczących m.in. tworzenia GUI w PyQt4/QtDesigner... i innych za pomocą Winka 2.0. Pierwszy "testowy" screencast dostępny jest w artykule Python pod MS Windows. Pomysły na screencasty i ogólnie sugestie co do ich zawartości mile widziane :) #python

Wirtualne pythony na Megiteam.pl

2009-10-13T21:16:58+00:00

Megiteam.pl w swoich dokumentach pomocy proponuje jeden sposób na oddzielenie swojego środowiska Pythona od systemowego, a także na ustalenie wersji Pythona, z jaką ma być uruchamiana aplikacja. Metodą prób i błędów doszedłem do innego, jak mi się wydaje także lepszego, sposobu na osiągnięcie tego celu.

Virtualenv na pomoc

Virtualenv ...

Guardian OpenPlatform

2009-10-12T13:38:37+00:00

Dostęp do artykułów i materiałów gazety The Guardian poprzez otwarte RESTowe API #python, #api, #rest, #guardian

Sieciowy framework zadań Gearman w Pythonowych aplikacjach

2009-10-10T14:37:20+00:00

Opis i wykorzystanie Gearmana - frameworka aplikacyjnego do zdalnego rozproszonego wykonywania zadań w różnych językach programistycznych #python, #gearman, #skalowanie

GROK 1.0

2009-10-09T17:05:02+00:00

Zespół odpowiedzialny za rozwój GROK - web-frameworka stworzonego przez społeczność Zope, na bazie Zope Toolkit - ogłosił, po 3 latach od startu projektu, wydanie finalnej wersji sygnowanej numerem 1.0. GROK, jak przystało na nowoczesny web-framework, pozwala na wydajną i produktywną pracę zarówno ekspertom jak i początkującym web-developerom. Dzięki możliwościom ponownego wykorzystania technologii GROK, podczas projektowania aplikacji, można łączyć go z Silva CMS oraz Plone CMS, które z powodzeniem współpracują z serwerem aplikacji Zope 2. Oprócz tego, framework jest w pełni kompatybilny z WSGI, co umożliwia na jego pełną integrację z szeroką gamą aktualnie dostępnych rozwiązań obsługujących ww. interfejs. Zmiany w finalnej wersji, w stosunku do wersji 1.0b2, to: ponowne usunięcie rejestracji karty IReRaiseException dla IUnauthorized, na rzecz używania konfigurowalnej funkcji fabrycznej debug_application_factory z aplikacji WSGI grokcore.startup, przejście na nowsze wersje simplejson oraz pytz; Pomimo osiągnięcia celu, twórcy nie osiedli na laurach. Zespół developerów pracuje cały czas zarówno nad rozwojem frameworka, jak i rozszerzeniem dostępnych informacji zawartych w dokumentacji. Już w najbliższym czasie można spodziewać się znaczących zmian. Źródło: grok.zope.org

Wyszukiwanie i agregacja projektów z github, bitbucket czy Google code

2009-10-09T10:22:54+00:00

Za pomocą prostych skryptów Pythona możemy wyszukiwać i agregować otwartoźródłowe projekty hostowane na serwisach takich jak Bitbucket, Github, czy Google Code #python, #github, #bitbucket, #google

Python 2.6.4rc1

2009-10-07T19:06:14+00:00

Niedawno na grupie dyskusyjnej comp.lang.python, Barry Warsaw zamieścił notkę informacyjną o wydaniu Pythona 2.6.4rc1. Wersja 2.6.4rc1 to krytyczna łata dla niedawno wydanej 2.6.3, w której tuż po premierze wykryto pewne niedogodności w pakiecie logowania i kompatybilności narzędzi setuptools. Poza tym, nie wprowadzono żadnych znaczących zmian (nie biorąc pod uwagę blisko 100 poprawek znajdujących się w wersji 2.6.3). Od teraz, aż do wydania finalnego Pythona 2.6.4 (które jest planowane na 18 października), gałąź 2.6.x pozostanie w trybie "tylko do łatania błędów", tym samym nie planuje się wprowadzenia żadnych nowości.

Thrift - framework usług siecowych

2009-10-07T16:31:41+00:00

Thrift pozwala tworzyć skalowalne i obsługujące wiele języków programistycznych usługi sieciowe na bazie RPC z wykorzystaniem złożonych struktur danych #python, #thrift, #ruby

Tworzenie Robotów Google Wave w Pythonie

2009-10-06T12:56:16+00:00

Artykuł wprowadzający do tworzenia robotów Google Wave napisanych w Pythonie i hostowanych na App Engine. #python, #googlewave, #wave, #gae

PyGoWave Server - niezależna implementacja serwera i klienta Google Wave

2009-10-04T17:30:16+00:00

PyGoWave Server to jedna z rozwijanych obecnie niezależnych implementacji serwera i klienta Google Wave. Źródła dostępne są na githubie, a wersja testowa znajduje się na pygowave.net. Projekt jest w bardzo wczesnym stadium rozwoju i nie oferuje jeszcze pełnej obsługi protokołu Fali.

PyGoWave wykorzystuje obecnie Pythona 2.6, Django 1.X, Orbited 0.7.7 (serwer Comet), RabbitMQ 1.6.0, a także PIL, lxml, czy carrot. Ostatnio także wykorzystywany jest Twisted. Opcjonalna zależność to django-rosetta. Od strony interfejsu webowego wykorzystywana jest biblioteka mootools i różne dodatki (zrzut ekranu).

Dla końcowego użytkownika nie jest to obecnie coś co można używać, natomiast programiści zainteresowani protokołem Federacji i Google Wave powinni przyjrzeć się temu projektowi i pomóc w jego rozwoju.

#wave, #google, #googlewave, #python, #django

Tokyo Cabinet - biblioteka baz danych klucz-wartość

2009-10-03T18:08:04+00:00

Opis bibliotek Tokyo Cabinet, Tyrant i Dystopia oferujących zbiór narzędzi do bardzo wydajnej obsługi baz danych działających na zasadzie klucz-wartość #python, #nosql, #sql, #bazydanych

Python 2.6.3

2009-10-02T23:29:17+00:00

Ukazała się trzecia wersja poprawkowa Pythona 2.6, w niej blisko 100 poprawionych błędów! Pełną listę zmian można znaleźć pod tym adresem. Już dzisiaj jest pewne, że ukaże się wersja 2.6.4, w której zostaną poprawione między innymi błędy związane z SSLem (issue5949). Przy okazji tego wydania warto wspomnieć, że developerzy Pythona powoli zaczynają pracę nad wersjami 2.7 i 3.2. Wstępne terminy ukazania się tych wersji języka ustalono na lato przyszłego roku. Aktualnie na liście dyskusyjnej python-dev trwają burzliwe dyskusje na temat dwóch nowo zaproponowanych modułów: argparse PEP 389 oraz ipaddr PEP 3144. Pobierz: Python 2.6.3 Źródło: python.org

Edycja dokumentów biurowych za pomocą Zoho Remote API

2009-10-02T17:48:08+00:00

Wykorzystujemy Zoho Remote API do edycji dokumentów, arkuszy i prezentacji w webowej aplikacji Django. Dostępny jest kompletny kod aplikacji. #python, #django, #zoho, #api, #saas, #office, #openoffice

Google Wave rozsyła zaproszenia do wersji testowej

2009-09-30T04:17:21+00:00

Od dzisiaj Google rozpoczęło rozsyłanie zaproszeń dla programistów i testerów, którzy wcześniej zapisali się na stosowne konto. Dzięki (ciągle rozbudowywanemu) API programiści mogą tworzyć gadżety i roboty poszerzające funkcjonalność Fal, wliczając w to roboty napisane w Pythonie. Oficjalnie Google Wave ma wystartować jeszcze w tym roku. Zainteresowanym polecam listę prezentacji i listę projektów związanych z Wave. #google, #wave, #python

Przegląd możliwości Zoho API i Zoho CloudSQL

2009-09-29T17:21:08+00:00

API usług Zoho.com pozwala integrować aplikacje z pakietu biurowego Zoho.com we własnych serwisach i narzędziach. Za pomocą Pythona można bez problemu operować na dostępnym API, w tym CloudSQL #zoho, #saas, #python, #sql, #api

Twisted - wprowadzenie: implementacja protokołu

2009-09-27T10:18:00+00:00

W poprzednim wpisie przedstawiłem obiekt reaktora oraz klasę Deferred. Kolejnym krokiem będzie napisanie serwera, który używając prostego protokołu będzie zwracał kod strony której adres został przesłany przez klienta.

Implementacja protokołu

Bazową klasą każdego protokołu, implementującą jedynie IProtocol jest internet.protocol.Protocol. Podstawową klasą dla wszystkich serwerów jest internet.protocol.ClientFactory:

>>> from twisted.internet import protocol, reactor
>>> 
>>> class WebGetProtocol(protocol.Protocol):
...     pass
... 
>>> class WebGetFactory(protocol.ServerFactory):
...     protocol = WebGetProtocol
...     
>>> reactor.listenTCP(9000, WebGetFactory())
<<class 'twisted.internet.tcp.Port'> of __main__.WebGetFactory on 9000>
>>> reactor.run()

Po utworzeniu instancji fabryki, przekazuję ją wraz z numerem portu jako parametr metody listenTCP obiektu reaktora. Wszelkie dane które pojawią się na tym porcie, obsłużone zostaną przez moją fabrykę.

Do połączenia z serwerem, można użyć na przykład programu telnet:

$ telnet localhost 9000
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
http://google.pl
...

Klasy Protocol i Factory

Ponieważ w twisted zastosowano wzorzec fabryki, przy implementacji nowego protokołu zawsze trzeba użyć co najmniej dwóch klas. Obiekt fabryki jest właściwym serwerem (lub klientem). Zarządza połączeniami i tworzy nowe instancje klasy protokołu, które odpowiedzialne są za obsługę konkretnego połączenia.

Logowanie ruchu

Pierwszą funkcjonalnością serwera będzie monitorowanie połączeń:

from twisted.python import log
log.startLogging(open('/tmp/myserver.log', 'w'))

class WebGetProtocol(protocol.Protocol):

    def connectionMade(self):
        log.msg('new connection')

    def connectionLost(self, reason=None):
        log.msg('connection lost: %s', reason)

Aby zapisywać wszystkie nawiązane i zerwane połączenia, zaimplementowałem metody connectionMade oraz connectionLost. Do logowania, zamiast modułu logging użyłem twisted.python.log.

$ tail -f /tmp/myserver.log
...
2009-09-28 01:11:21+0200 [__main__.WebGetFactory] new connection
2009-09-28 01:11:24+0200 [WebGetProtocol,0,127.0.0.1] connection lost: %s
[Failure instance: Traceback (failure with no frames): <class
'twisted.internet.error.ConnectionDone'>: Connection was closed cleanly.
     ]

Przesyłanie danych

Kolejnym krokiem będzie czytanie i wysyłanie danych, które zakończone będą znakiem powrotu karetki i nowego wiersza. Pomysł używania \r\n jest na tyle popularny, że w twisted jest już gotowa klasa do wymiany danych w ten sposób. LineReceiver implementuje ten sam interfejs co protocol.Protocol, więc nie trzeba zmieniać napisanego do tej pory kodu.

from twisted.web.client import getPage
from twisted.protocols.basic import LineReceiver

class WebGetProtocol(LineReceiver):

    def lineReceived(self, line):
        deferr = getPage(line)
        deferr.addCallback(self.send_success).addErrback(self.send_errback)

    def send_success(self, data):
        data = data.replace('\r\n', '')
        self.sendLine(data)

    def send_errback(self, err):
        self.sendLine('Server error')
        self.transport.loseConnection()

Po otrzymaniu danych (lineReceived), pobieram stronę znajdującą się pod przesłanym adresem. Nie wiadomo jednak jak szybko odpowie serwer, dlatego zamiast czekać na zakończenie przesyłania danych używam getPage, a do zwróconego obiektu Deferred dodaję własny callback i errback . Reaktor nie jest blokowany i czekając na odpowiedź, może uruchomić inne zadania.

W przypadku wystąpienia błędu chcę zerwać połączenie z klientem. Potrzebny jest do tego obiekt typu WebGetFactory. Każdy protokół posiada jednak referencję do swojej fabryki, która trzymana jest pod atrybutem transport. Ostatnia linia metody send_errback odpowiada więc za zerwanie połączenia.

Aplikacja Twisted

Pisząc program zawsze trzeba dodać sporo powtarzającego się kodu. Demonizacja aplikacji, logowanie, uruchamianie i wyłączanie programu to tylko te najczęściej występujące funkcjonalności. Twisted zawiera na szczęście interfejs który pozwala zaimplementować to wszystko w paru linijkach.

Z dotychczas napisanego kodu usunąć można ostatnie linijki. twistd sam zajmie się wyborem odpowiedniego reaktora i jego uruchomieniem. Jedyne co trzeba zrobić to utworzyć obiekt o nazwie application:

from twisted.application import internet, service

# ...

#reactor.listenTCP(9000, WebGetFactory())
#reactor.run()

application = service.Application("webget")
webget = internet.TCPServer(9000, WebGetFactory())
webget.setServiceParent(application)

Plik zapisać należy z rozszerzeniem .tac, które informować będzie, że kod Pythona znajdujący się w tym pliku zawiera obiekt Application i uruchamiać go należy używając twistd:

$ twistd -noy simple_server.tac -l /tmp/myserver.log

Kod użyty jako przykłady pobrać można z github

Jython 2.5.1

2009-09-26T20:04:42+00:00

Ukazała się pierwsza wersja poprawkowa Jythona 2.5, nie wnosząc co prawda ona żadnych nowości, a poprawiając zgłoszone błędy. Najpoważniejszym błędem, mogącym prowadzić do utraty danych, była niepoprawna obsługa plików otwieranych w trybie dopisywania(append). Z pozostałych zmian można wymienić poprawę działania relatywnych importów, które w pewnych przypadkach mogły działać nieprawidłowo, oraz poprawa parsowania coroutines(PEP342), które prowadziło do błędu krytycznego Jythona. Szczegółowa lista zmian znajduje się w pliku NEWS w katalogu Jythona. Więcej informacji: Jython 2.5.1 Źródło: fwierzbicki.blogspot.com

Byte of Python po polsku

2009-09-26T13:58:23+00:00

Dobra wiadomość dla początkujących programistów Pythona! Otóż w polskich materiałach dydaktycznych pojawi się niedługo kolejna, darmowa książka! A to za sprawą Dominika Kozaczko - nauczyciela informatyki V LO w Bielsku-Białej i organizatora konferencji Dni Wolnego Oprogramowania - oraz jego uczniów. Byte of Python (autorstwa Swaroopa C H) to znana na całym świecie pozycja - dedykowana środowiskom akademickim - przetłumaczona już na 18 języków. Dostępna dla wersji Pythona 2.x i 3.x w formacie HTML i PDF. Jak udało się ustalić, tłumaczenie trwa od marca tego roku i jest już na etapie końcowym. Planowany deadline to koniec września. Z pewnością koledzy będą potrzebowali pomocy przy erracie, dlatego też wszelkie sugestie należy zgłaszać, bądź bezpośrednio modyfikować treść na WIKI, dokonując wcześniej rejestracji. Tłumaczenie polskie wybiega trochę poza schemat pozostałych książek, gdyż jest tłumaczeniem hybrydowym Byte of Python v. 1.92, dot. Pythona 3.x oraz starszej wersji 2.x. Jak mówią sami twórcy: "Zdecydowaliśmy się na ten krok, ponieważ Python 2.x jest jeszcze najpopularniejszy, za to nowa wersja BoP ma lepsze walory dydaktyczne - czyli uzyskaliśmy jakieś 120% oryginału." Co więcej, planowane też jest wydanie książki w formacie PDF oraz rozszerzenie działalności na wydanie publikacji. W związku z tym na rynku pojawi się w formie drukowanego podręcznika. Zachęcam do śledzenia postępów prac nad książką. Przede wszystkim gratuluję pomysłu autorom tego przedsięwzięcia!

Learning Python - IV Edycja

2009-09-25T23:20:35+00:00

Od dziś dostępna jest czwarta edycja książki Learning Python, w Polsce znanej jako Python. Wprowadzenie. Jest to jedna z najbardziej rozpoznawalnych pozycji na międzynarodowym rynku, dla osób chcących nauczyć się programować w Pythonie. Jej autorem jest znana osobistość pythonowej społeczności - Mark Lutz. Najnowsza edycja wprowadza kilka zmian, do których można zaliczyć: dokładne omówienie składni i elementów Pythona 2.6 i 3.0, uzupełnienie obecnych zagadnień o nowe informacje (np. szczegóły dot. Unicode, bardziej realistyczne i przyjazne przykłady OOP czy tematy opisujące metaklasy), dokładniejszy opis zgromadzonych narzędzi atrybutów oraz deskryptorów, opis specyficznych rozszerzeń językowych dla Pythona 2.6 i 3.0, zmiany w obecnych materiałach polegające na reorganizacji dotychczasowych przykładów lub dodaniu nowych; Anglojęzyczną wersję podręcznika można już zamawiać w księgarni internetowej O'Reilly. Na informacje o realizacji jej polskiego tłumaczenia, dane jest nam jeszcze poczekać.

Learning Python - IV Edycja

2009-09-25T23:20:35+00:00

Twisted - wprowadzenie: reactor i deferred

2009-09-25T18:39:33+00:00

Śledząc portale i blogi o treści programistycznej, trudno nie zauważyć wzmożonego ostatnio zainteresowania "nowymi" asynchronicznymi frameworkami napisanymi w Pythonie. Osobiście staram się jednak nie podniecać każdą nowością i aby się przekonać do biblioteki, potrzebuję czegoś więcej niż 10 linijek kodu, wyświetlających Hello world. Okazało się, że nie ja jedyny.

Od jakiegoś czasu czytam o twisted i w miarę możliwości staram się napisać trochę działającego kodu. Niestety, oprócz tutoriala w którym opisane zostały podstawy, do dyspozycji jest jeszcze tylko dokumentacja API.

Ponieważ sam dużo czasu spędziłem na gromadzeniu informacji, postaram się w miarę przystępnie opisać podstawy twisted.

Reaktor

Ponieważ twisted jest asynchronicznym frameworkiem, posiada własny obiekt odpowiedzialny za zarządzanie główną pętlą programu i wywoływanie obsługi zdarzeń:

>>> from twisted.internet import reactor

Oprócz podstawowej wersji, można wybrać spośród wielu innych implementacji.

Aby uruchomić reactor, należy wywołać na nim metodę run().

>>> reactor.run()

Deferred

Podstawowym "obiektem zadaniowym" jest w twisted Deferred. Dzięki niemu można zakolejkować i powiązać w łańcuch dowolną ilość zadań.

>>> from twisted.internet.defer import Deferred

Programując asynchronicznie używamy jednego procesu (przynajmniej na początku), który wykonuje kolejne zadania nadsyłane przez reaktor. Każde z tych zadań dostaje na swoje wykonanie tyle czasu ile potrzebuje, dlatego długo wykonujące się funkcje mogą skutecznie zamrozić aplikacje. Jeśli jednak opóźnienie spowodowane jest oczekiwaniem na jakieś zdarzenie, a nie przez czasochłonne obliczenia, problem można rozwiązać tworząc łańcuch małych porcji instrukcji.

Callback

Callback traktować można jako filtr z efektami ubocznymi. W najprostszym przypadku będzie to funkcja zwracająca przyjmowany argument:

>>> transparent_callback = lambda arg: arg

Filtry (ze względu na brak lepszej nazwy, tak będę nazywał te obiekty) łączyć można w łańcuchy wywołań. Wynik działania każdego z nich przekazywany jest jako argument wywołania kolejnego:

>>> from twisted.internet.defer import Deferred
>>>
>>> def double(x):
 ...    return x * 2
 ...
>>> def inc(x):
 ...    return x + 1
 ...
>>> d = Deferred()
>>> d.addCallback(double)
<Deferred at 0x860be4c>
>>> d.addCallback(inc)
<Deferred at 0x860be4c>
>>>
>>> d.callback(3)
>>> d.result
7

Errback

Ponieważ działanie filtru może zakończyć się błędem, obiekt typu Deferred pozwala na zdefiniowanie oddzielnej listy instrukcji do ich obsługi:

>>> def error_handler(error):
 ...    print error
 ...
>>> def fail(data):
 ...    raise Exception('Fail!')
 ...
>>> d = Deferred()
>>> d.addCallback(fail).addErrback(error_handler)
<Deferred at 0x863bd0c>
>>>
>>> d.callback(None)
[Failure instance: Traceback: <type 'exceptions.Exception'>: Fail!
/usr/lib/python2.6/site-packages/IPython/iplib.py:2257:runcode
<ipython console>:1:<module>
/usr/lib/python2.6/site-packages/twisted/internet/defer.py:243:callback
/usr/lib/python2.6/site-packages/twisted/internet/defer.py:312:_startRunCallbacks
--- <exception caught here> ---
/usr/lib/python2.6/site-packages/twisted/internet/defer.py:328:_runCallbacks
<ipython console>:2:fail
]

DeferredList

Oprócz grupowania filtrów, utworzyć można obiekt czekający na zakończenie ustalonego zbioru instancji Deferred.

>>> from twisted.internet import defer 
>>> 
>>> def printer(data):
...     print data
... 
>>> d1 = defer.Deferred()
>>> d1.addCallback(lambda x: x * 2).addCallback(lambda x: x + 1)
<Deferred at 0x93efd6c>
>>> d2 = defer.Deferred()
>>> d2.addCallback(lambda x: x / 2).addCallback(lambda x: x - 1)
<Deferred at 0x93efdcc>
>>>
>>> dl = defer.DeferredList([d1, d2])
>>> dl.addCallback(printer)
<DeferredList at 0x93f468c>
>>>
>>> d1.callback(2)
>>> d2.callback(4)
[(True, 5), (True, 1)]

Przykłady

Będąc na tym etapie znajomości twisted zastanawiałem się, jaki sens ma używanie Deferred skoro wystarczy użyć zwykłego time.sleep() aby skutecznie zablokować na jakiś czas aplikację.

>>> import time
>>>
>>> def check(deferred, data):
...     start_time = time.time()
...     d.callback(data)
...     print 'work time:', time.time() - start_time
...     
>>> def sleeper(sleep_time):
...     time.sleep(sleep_time)
...     return sleep_time
... 
>>> d = defer.Deferred()
>>> d.addCallback(sleeper).addCallback(sleeper)
<Deferred at 0x943c28c>
>>> check(d, 2)
work time: 4.00436711311

Gdybym użył procesów i dostosował funkcję check, zamiast 4 sekund wszystko trwałoby niewiele ponad 2. Po co więc programować asynchronicznie? Najlepiej wytłumaczę to chyba kolejnym fragmentem kodu z wykorzystaniem funkcji getPage:

>>> import time
>>> from twisted.web.client import getPage
>>> from twisted.internet import defer
>>> from twisted.internet import reactor
>>> 
>>> URLS = ['http://distrowatch.com/', 'http://www.vim.org/']
>>> 
>>> def pull_page(page):
...     print 'done'
... 
>>> 
>>> def end_work(result):
...     reactor.stop()
... 
>>> 
>>> deferreds = [getPage(url) for url in URLS]
>>> 
>>> for d in deferreds:
...     d.addCallback(pull_page)
... 
<Deferred at 0x90c79ec>
<Deferred at 0x90c7c8c>
>>> 
>>> dl = defer.DeferredList(deferreds)
>>> dl.addCallback(end_work)
<DeferredList at 0x90c7fcc>
>>> 
>>> start_time = time.time()
>>> reactor.run()
done
done
>>> print 'work time:', time.time() - start_time
('work time:', 1.927487850189209)

Aby pobrać dwie strony, używam getPage które zwraca obiekt Deferred. Do każdego obiektu z listy deferreds podpinam własny callback który wyświetli napis done. Dzięki temu wiem jak szybko pobrana została każda ze stron. Na koniec tworzę DeferredList, który po zakończeniu wszystkich zadań wyłączy reaktor. Czas działania skryptu - 2 sekundy.

A co jeśli zwiększę ilości stron do pobrania z 2 do 40? Gdybym napisał to w pętli przy użyciu urllib.urlopen, operacja trwałaby 20 razy dłużej. W przypadku twisted nie jest to takie oczywiste:

>>> URLS = URLS * 20
...
>>> print 'work time:', time.time() - start_time
('work time:', 24.748102903366089)
>>> 24.748102903366089 / 1.927487850189209
12.839563632495389

RuPy 2009 - otwarcie rejestracji

2009-09-22T20:50:03+00:00

Zgodnie z ustalonym terminem, rejestracja na trzecią edycję konferencji RuPy 2009 została otwarta, gdzie do samej imprezy pozostał ponad miesiąc. Warto również w tym miejscu zwrócić uwagę na cenę uczestnictwa, która z kolejnymi tygodniami staje się co raz większa. Dlatego też zachęcam do natychmiastowej rejestracji - nie tylko z ekonomicznego punktu widzenia - gdyż ilość miejsc jest ograniczona! Uzupełniając wcześniejsze informację, konferencja odbędzie się na Uniwersytecie im. Adama Mickiewicza w Poznaniu, dokładnie w tym samym miejscu co zeszłoroczne edycje imprezy. Będziemy mieli do dyspozycji 2 aule, w związku z czym rozporządzanie wszystkimi prelekcjami (a będzie ich około 20), nie będzie stanowić problemu. Zaktualizowaliśmy również dane logistyczne oraz te związane z zakwaterowaniem. Natomiast ostateczną Agendę udostępnimy na początku października. Zapraszamy do śledzenia strony konferencji: RuPy 2009