Autor
Tomasz Karbownicki, absolwent informatyki na Politechnice Opolskiej. Fan Linuksa oraz otwartego oprogramowania. Obecnie programista aplikacji internetowych.
RSS
Wszystkie:
Linux:
Szukaj
Kategorie
Archiwum
Pokaż archiwum
Ukryj archiwum
- Styczeń 2010 (1)
- Grudzień 2009 (1)
- Listopad 2009 (3)
- Październik 2009 (2)
- Czerwiec 2009 (2)
- Maj 2009 (1)
- Kwiecień 2009 (2)
- Marzec 2009 (1)
- Luty 2009 (2)
- Styczeń 2009 (2)
- Grudzień 2008 (2)
- Listopad 2008 (3)
- Październik 2008 (2)
- Wrzesień 2008 (2)
- Sierpień 2008 (2)
- Czerwiec 2008 (4)
- Maj 2008 (1)
- Kwiecień 2008 (2)
- Marzec 2008 (1)
- Luty 2008 (9)
- Styczeń 2008 (6)
- Listopad 2007 (3)
- Październik 2007 (4)
- Wrzesień 2007 (1)
- Sierpień 2007 (7)
- Lipiec 2007 (1)
- Czerwiec 2007 (6)
- Maj 2007 (1)
- Marzec 2007 (6)
- Luty 2007 (4)
- Październik 2006 (2)
- Wrzesień 2006 (3)
- Sierpień 2006 (13)
- Czerwiec 2006 (4)
- Maj 2006 (4)
- Kwiecień 2006 (1)
- Marzec 2006 (2)
- Luty 2006 (6)
- Styczeń 2006 (8)
- Grudzień 2005 (8)
- Listopad 2005 (9)
- Październik 2005 (8)
- Wrzesień 2005 (16)
- Sierpień 2005 (6)
Blip
Zawsze mnie ciekawiło jaki jest ruch na naszym firmowym serwerze ale nie chciałem obciążać maszyny dodatkowym oprogramowaniem, które by to zliczało. Zwłaszcza że każda hostowana przez nas strona jest podpięta pod Google Analytics. Nie znalazłem jednak sposobu aby w panelu statystyk wyświetlić sumę odwiedzin z kilku kont. Na szczęście Analytics podobnie jak większość usług Googla ma swoje API. Wystarczyło więc zaprząc do pracy Pythona oraz bibliotekę gdata.
Użytkownikom ArchLinuksa polecam paczkę python-gdata-svn
yaourt -S python-gdata-svn
Skrypt jest dość prosty i działa w konsoli:
#!/usr/bin/python
import datetime
import sys
import gdata.analytics
import gdata.analytics.service
def main(argv):
GOOGLE_ANALYTICS_LOGIN = 'TWOJE@KONTO'
GOOGLE_ANALYTICS_PASSWORD = 'TAJNE_HASLO'
if len(argv) > 1:
d = argv[1].split('-')
data = datetime.date(int(d[0]), int(d[1]), int(d[2]))
else:
data = datetime.datetime.now()
print "\ndata: %d-%d-%d" % (data.year, data.month, data.day)
print "\nodw\tods\tdomena"
print "--------------------------"
dc = gdata.analytics.service.AnalyticsDataService()
dc.ClientLogin(GOOGLE_ANALYTICS_LOGIN, GOOGLE_ANALYTICS_PASSWORD, account_type='GOOGLE')
a = dc.GetAccountList()
odwiedziny, odslony = [], []
for b in a.entry:
tid = b.id.text.replace('http://www.google.com/analytics/feeds/accounts/','')
query = dc.GetData(
ids=tid,
start_date='%.4d-%.2d-%.2d' % (data.year, data.month, data.day),
end_date='%.4d-%.2d-%.2d' % (data.year, data.month, data.day),
metrics='ga:visitors,ga:pageviews',
dimensions='ga:day'
)
odw = int(query.entry[0].visitors.value)
ods = int(query.entry[0].pageviews.value)
odwiedziny.append(odw)
odslony.append(ods)
print "\033[1;31m%d\t%d\033[0m\t\033[33m%s\033[0m" % (odw, ods, b.title.text)
print "--------------------------"
print "%d\t%d\tRazem" % (sum(odwiedziny),sum(odslony))
if __name__ == "__main__":
sys.exit(main(sys.argv))
Jeżeli wywoła się go bez parametrów wówczas pokaże statystyki dla dnia dzisiejszego. Można też podać mu jako parametr datę, np:
python stats.py 2012-12-21
Przykładowy wynik działania wygląda tak:
Obecnie w czasach interfejsów napędzanych JavaScriptem coraz widoczniejszy staje się problem składowania danych w HTML-u. Prosty przykład: mamy generowany formularz, który chcemy zweryfikować za pomocą JavaScriptu. Przy generowaniu formularza posiadamy dla każdego pola zmienną mówiącą nam o tym czy to pole jest wymagane czy nie. I tu pojawia się problem, jak oznaczyć np. inputa jako pole wymagane? Struktura formularza nie daje nam miejsca na składowanie takich danych. Można kombinować z wrzuceniem jakiegoś słowa kluczowego do id. np:
id="required"
No ale id musi być niepowtarzalne, więc może klasa...
class="required"
Może, ale w sumie mam już tam kilka innych klas
class="specjalne kontrast required"A więc czy klasa to na pewno dobre miejsce? Jasne że nie, klasa jest dla styli. No więc jak? Trzeba stworzyć własny atrybut! Niby jasne, ale przecież validator nie uznaje własnych atrybutów...
Otóż uznaje. Trzeba je tylko zadeklarować w definicji dokumentu - DTD (Document Type Definition). Załóżmy że chcemy wzbogacić nasz input w atrybut required. Wystarczy więc taka konstrukcja DTD:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
[
<!ATTLIST input required CDATA #IMPLIED>
]>
Ta dekladacja zezwala atrybutowi required posiadać dowolną wartość znakową. Jeżeli chcielibyśmy ograniczyć wartość jedynie do dwóch pozycji wystarczy zastosować coś takiego:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
[
<!ATTLIST input required (true|false) #IMPLIED>
]>
Ogólny schemat jest taki:
ATTLIST element atrybut typ opcjnonalnyStatus
No i gotowe. Teraz możemy zaprząc JavaScript do podjęcia odpowiednich działań na podstawie struktury dokumentu. Czyli np. w jQuery:
$('input[required='true']').PrzypilnujInteresu();
Prosto czysto i funkcjonalnie.
Materiał źródłowy:
http://www.alistapart.com/articles/customdtd/
PS. Remember remember the fifth of november...
Google preview to moja ulubiona wtyczka rozszerzenie dla Firefoksa, bez której wyniki wyszukiwania w Googlu po prostu nie wyglądają. Wstawia ona obok każdej pozycji miniaturkę strony, a ponieważ człowiek myśli obrazami więc o wiele szybciej można namierzyć szukaną witrynę. Niestety w przeglądarce Google Chrome (która ostatnio stała się moją podstawową przeglądarką) nic takiego nie istnieje. Istnieje już jednak system rozszerzeń (chociaż ukryty) oraz podstawowa dokumentacja, więc postanowiłem sam zapchać lukę.
Na początek przyda się nam developerska wersja Chroma (nie wiem czy wersja stabilna posiada tą funkcjonalność, jeżeli tak to niech mnie ktoś poprawi). Dla użytkowników ArchLinuksa polecam paczkę z AUR - google-chrome-dev.
yaourt -S google-chrome-dev
Aby uruchomić ukryty jeszcze mechanizm obsługi rozszerzeń należy uruchomić przeglądarkę z parametrem -–enable-extensions.
google-chrome -–enable-extensions
Teraz wystarczy już tylko pobrać przygotowane przeze mnie rozszerzenie i potwierdzić chęć instalacji
ChromePreview 0.38
Od tej chwili możemy się już cieszyć pięknymi miniaturkami
O ile wszystko dobrze poskładałem to rozszerzenie powinno się samo aktualizować (w razie W). Jeżeli ktoś jest zainteresowany bebechami to dołączam pliki:
Listę zainstalowanych rozszerzeń znajdziecie wstukując do paska adresu chrome://extensions/
EDIT: rozszerzenie znajdziecie w otwartej dzisiaj bazie rozszerzeń pod adresem https://chrome.google.com/extensions/detail/behjpjkdajdecgkkamhaplpkcbkceaie
Jak każdy djangowic dobrze wie plik settings.py przechowuje wszelkie ustawienia aplikacji począwszy od nazwy strony a na listach middleware'u czy liście zainstalowanych aplikacji skończywszy. Ponieważ zawiera on wszelkie ustawienia, musi być inny dla developera a inny dla serwera produkcyjnego (np. z powodu tego, że developer ma DEBUG=True).
Pierwszą możliwością rozwiązania tego problemu jest ignorowanie pliku settings.py przez repozytorium kodu, tak aby różne zawartości tego pliku nie powodowały konfliktów. Wadą takiego rozwiązania jest potrzeba ręcznego edytowania tego pliku na serwerze kiedy np. dodajemy nową aplikację do INSTALLED_APPS. Moje repozytorium aktualizuje stronę na serwerze po każdym commicie, więc ręczna edycja settings.py jest męcząca.
Drugą możliwością jest stworzenie osobnych ustawień dla serwera i osobnych dla developera. Django umożliwia uruchomienie serwera z podaniem pliku ustawień jako parametr:
python manage.py runserver --settings=settings-developer.pyWszystko wydaje się być ok. Jeżeli coś zmieniamy to dokonujemy zmiany w settings.py, settings-developer.py i po commitcie wszystko gra. Czasami jednak przy testowaniu różnych rzeczy w pliku developera można zapomnieć o settings.py i po commicie znowu strona jest rozwalona. Poza tym nie każdy developer korzysta z tych samych ustawień. Jeden używa Django Debug Toolbar inny ColorSQLMiddleware więc trzeba by zrobić tyle settings-xxx ilu developerów. A później przy zmianie czegoś globalnego edytować wszystkie...
Ostatecznym rozwiązaniem okazało się przeciążenie pliku settings.py przez ponowną deklarację zmiennych lub rozszerzenie już istniejących wartości. Jak to zrobić?
- Tworzymy plik, który będzie przetrzymywał nasze lokalne ustawienia, np. settings-local.py
- Na końcu pliku settings.py dodajemy kod:
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
execfile('%s/settings-local.py' % BASE_DIR)Teraz w pliku settings-local.py możemy ponownie zadeklarować zmienne które mają zostać przeciążone lub rozszerzyć zadeklarowane już w settings.py listy. Np. kiedy jeden z developerów chce użyć Django Debug Toolbar dodaje do settings-local.py taki kod:
MIDDLEWARE_CLASSES += (
'debug_toolbar.middleware.DebugToolbarMiddleware',
)
INSTALLED_APPS += (
'debug_toolbar',
)
DEBUG_TOOLBAR_PANELS = (
'debug_toolbar.panels.sql.SQLDebugPanel',
'debug_toolbar.panels.headers.HeaderDebugPanel',
'debug_toolbar.panels.cache.CacheDebugPanel',
'debug_toolbar.panels.profiler.ProfilerDebugPanel',
'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
'debug_toolbar.panels.templates.TemplatesDebugPanel',
# If you are using the profiler panel you don't need the timer
# 'debug_toolbar.panels.timer.TimerDebugPanel',
)Plik settings-local.py wywalamy z repozytorium i w ten sposób otrzymujemy elastyczny mechanizm współdzielenia wartości globalnych przy jednoczesnej personalizacji ustawień lokalnych.
Obecnie pracuję jako programista aplikacji internetowych w małym zespole. Realizujemy kilka projektów w miesiącu i dość trudno jest zapanować nad wszystkimi zadaniami, które trzeba wykonać. W przypadku większych projektów korzystamy z Trac'a, jednak do mniejszych nie nadaje się on za dobrze ponieważ trzeba dla każdego projektu tworzyć nową instancję i nie ma jak zrobić zbiorczego zestawienia. Rozglądałem się więc za jakimś kompleksowym rozwiązaniem, które dawałoby możliwość ogarnięcia kilku projektów wraz ze śledzeniem repozytoriów Subversion.
Powstało już wiele serwisów oferujących podobną funkcjonalność. Wśród najbardziej znanych wymienić można:
Główną wadą pierwszych trzech rozwiązań jest to, że nie można ich hostować na własnym serwerze a jedynie wykupuje się konto na serwerze producenta. Collabtive jest co prawda aplikacją na licencji GNU GPL i można postawić to u siebie, ale z kolei zupełnie nie obsługuje repozytoriów kodu.
I tutaj pytanie do Was. Czego Wy używacie w pracy? Być może jest jakiś fajny projekt który przeoczyłem.
PS. Swoją drogą to dziwne, że nikt jeszcze czegoś podobnego w Django nie zrobił.
Ostatnio wpadł mi w ręce bardzo ciekawy moduł Pythona, który śmiało można określić jako jQuery po stronie serwera. Jeżeli potrzebowaliście kiedyś wyciągnąć jakieś dane z kodu HTML-a i denerwowała was zabawa z parsowaniem kodu za pomocą sgmllib czy innego tego typu wynalazku, to wasze cierpienia właśnie się skończyły.
Jak to działa?
Na początek pobierzemy zawartość jakieś strony, z której chcemy wyciągnąć dane. Ja posłużę się stroną antyweb.pl, ponieważ jest całkiem przystępnie zakodowana.
from pyquery import PyQuery as pq
import urllib
html = urllib.urlopen("http://antyweb.pl").read()
html = pq(html)Teraz wystarczy już zadecydować co chcemy wyciągnąć i po prostu to zrobić :-) Np. informacje o autorze
print html("#f li.frt").text()Wynik:
Witaj, nazywam sie Grzegorz Marczak i jestem autorem tego bloga. Piszę tutaj o serwisach spolecznosciowych, nowych technologiach i nowych trendach w internecie.
Wyciągnięcie wszystkich kategorii
for a in html("li.categories a"):
print a.textWynik:
antytydzień Biała flaga
Ciekawe strony
Świat
Miniblog
Mobilnie
Moje przemyślenia
Off topic
polska
Pytamy.pl
Startups
To mnie drażni.
Uncategorized
W trakcie tworzenia
wywiady
Wyszukanie najczęściej komentowanego wpisu ze strony głównej
max_comments = 0
title = ''
for a in html("ul.clnn li.l a"):
try:
# liczba komentarzy
comments = int(a.text.split(" ")[1])
if max_comments < comments:
max_comments = comments
# nazwa wpisu
title = a.values()[1].replace("Komentarze do wpisu ",'')
except:
pass
print "Najwiecej komentarzy: %s" % max_comments
print "Wpis: %s" % titleWynik:
Najwiecej komentarzy: 32
Wpis: Interia mówi, tak kupujemy ruch (bo inni też tak robią)
Więcej
To oczywiście tylko mała próbka możliwości. pyquery pozwala również na manipulację stylami (addClass, toggleClass, removeClass, attr, css) czy samą strukturą danych (append, prepend, prependTo, insertAfter, remove, replaceWith itd.). Jeżeli posiadamy moduł WebOb możemy też zaprzęgnąć do pracy Ajax.
Po więcej informacji zapraszam na stronę projektu pyquery.
Ostatnio rozglądałem się za tutorialem do budowy prostego gadżetu w Pythonie, który siedział by sobie na przezroczystym tle na moim pulpicie. Gadżety Screenlets czy gDesklets działają różnie, zazwyczaj niestabilnie albo, któryś (akurat przydatny) całkowicie się nie odpala. Poza tym potrzebowałem coś maksymalnie prostego a nie całej platformy dla gadżetów.
Wpadłem więc dziś na pomysł wykorzystania Tildy jako ładnego kontenera. W zasadzie to do pełni szczęścia potrzebne były dwie paczki: tilda i python-feedparser. Znajdziecie je w każdej dystrybucji. Dla archowców:
# pacman -S tilda python-feedparser
Tildę najlepiej skonfigurować następująco:
W sekcji Command w polu Custom Command umieszczamy adres skryptu, ale o tym za chwilę.
Teraz czas na Pythona. Wystarczy sworzyć malutki skrypt o takiej treści:
#! /usr/bin/env python
import feedparser
import time
import os, sys
# nieskonczona petla
while 1:
# pobierz RSS
feed = feedparser.parse("http://jogger.pl/rss/")
# wyczysc ekran
sys.stdout.write(os.popen('clear').read())
# dla kazdego wpisu
for note in feed['entries']:
# wypisz tytul
print "- %s" % note['title']
print "\nhttp://jogger.pl/"
# odczekaj 60 sekund
time.sleep(60)
Skrypt wystarczy zapisać np. jako jogger.py i wpisać ścieżkę do niego w polu Custom Command. W moim przypadku jest to:
python /home/tomek/go/python/jogger.py
I to by było na tyle. Po ponownym uruchomieniu Tildy powinniśmy mieć ładny przegląd wydarzeń na joggerze odświeżany co 60 sekund. Gdy coś nas zainteresuje wystarczy przytrzymać ctrl i kliknąć link do joggera.
Oczywiście może to być dowolny kanał RSS/Atom czy coś zupełnie innego np. statystyki obciążenia naszego serwera. Żadnych tam Googlowych gadżetów z tysiącem funkcji. Prosto łatwo i przyjemnie.
Od dawna chciałem już zrobić coś związanego z kamerą. W tym semestrze nadarzyła się okazja i zaproponowaliśmy prowadzącemu własny temat projektu z przedmiotu o nazwie „struktury systemów informatycznych”. Naszym zamierzeniem było stworzenie programu, który działałby podobnie jak gesty wykonywane myszą w Firefoksie tyle, że rolę myszki odegrać miała kamera. Założenia wstępne: platforma – Linux, język – Python.
Najwięcej problemów sprawiła nam sama kamera, a dokładniej to zbieranie i przetwarzanie jej obrazu.
Na początku zabraliśmy się za testowanie reacTIVision, które w zasadzie jest oprogramowaniem dla ekranów wielodotykowych. ReacTIVision ma swoją bibliotekę 89 symboli, które potrafi rozpoznać określając ich numer id, pozycję x-y, kąt nachylenia a nawet przyśpieszenie.
Symbole wyglądają tak:
Kamera widziała to tak:
A reacTIVision tak:
Działo to całkiem sprawnie. Jeżeli wykonaliśmy szybszy ruch markerem, a dokładniej przyśpieszenie markera przekroczyło pewną granicę, wówczas rozpoczynał się rysować gest. Wadą jednak tego rozwiązania były markery. Jeżeli nie miało się markera to program był bezużyteczny. Trzeba było więc go zastąpić czymś co ma każdy, np. ręką :-)
Do łapania obrazu z kamery tym razem wykorzystaliśmy moduł Pythona pyvideograb. Znaleźliśmy nawet bardzo przydatny skrypt, który wykrywał punkty ruchu w obrazie poprzez porównywanie dwóch sąsiednich klatek. Co prawda autorzy zaznaczyli, że działa tylko pod Windowsem z uwagi na moduł do przychwytywania obrazu z kamery, ale ten łatwo można było podmienić.
Teraz wystarczyło wrzucić wszystko do Pygame’a i już pierwsze efekty były widoczne.
Program wykrywał ruch i potrafił określić współrzędne punktu ruchu, co w przypadku poruszającej się większej powierzchni oznaczało jej środek.
Po naciśnięciu spacji możemy już wykonywać gest.
Następny etap to sieć neuronowa a dokładniej sieć Hopfielda. Dzięki niej jesteśmy w stanie rozpoznać, czy wykonany gest zgadza się z jednym z 4 wzorców. Jeżeli tak, wykonywane jest przypisane do niego polecenie.
W konsoli wygląda to tak:
W tej chwili program ma wprowadzone 4 wzorce (plik: patterns.txt)
Przypisane do nich działania można łatwo edytować (interfejs.py)
Jeżeli ktoś miał by ochotę się tym pobawić lub zrobić z tym coś więcej to proszę bardzo.
Gesty v0.001 na licencji GNU GPL
Projekt – 4.5, radość ze zrealizowanego pomysłu – bezcenna ;-)
Współautorzy:
– Marek Knaga
– Jarosław Miazga
UPDATE: ponieważ strona projektu pyvideograb od jakiegoś czasu jest martwa zamieszczam spakowany moduł pyvideograb.tar.gz
Moje ostatnie narzekania na organizację repozytorium w Archu nie dawały mi spokoju. Dzisiaj z pomocą fixxxera (właściwie to tylko przerobiłem jego skrypt ;) powstał skrypt, który po otrzymaniu nazwy pakietu pokazuje nam do jakiej kategorii jest on przypisany w repozytoriach Gentoo.
Składania jest prosta:
$ python portage.py gajim
net-im
Oczywiście bez dwóch zdań będą jakieś niezgodności
$ python portage.py pacman
games-arcade
Ale na ogół skrypt powinien działać dobrze. Czyli pierwszy krok do kategoryzacji Archa zrobiony. Teraz tylko powkładać pakiety w kategorie, zrobić GUI i można podbijać świat ;-)
Ostatnio zaczynam mieć dość webowych aplikacji. Oglądanie wszystkiego w przeglądarce nie zawsze jest wygodne, no i nie zawsze szybkie zważywszy na ilość rozszerzeń jakie wcieliłem do Firefox-a. Czasami też wyłączam okno przeglądarki zapominając, że w któreś z zakładek siedzi coś co np. odtwarza muzykę z Jamendo. Do webaplikacji Googla używam już od jakiegoś czasu Prisma. Działa to lepiej ale nadal nie jest to /to coś/ czego szukam. Jeżeli mogę staram się używać aplikacji natywnych np. Gmail via Thunderbird (przez IMAP) czy Google Calendar via Lightning (rozszerzenie do Trunderbird-a). Aplikacje webowe mają jednak bardzo dobrą cechę – są mobilne. Nie mając naszych ulubionych aplikacji pod ręką i tak zawsze się do nich dostaniemy choćby przez tfu IE tfu.
Dzisiaj trochę bawiłem się PyGTK wynikiem czego wykombinowałem mały skrypt. Sam się zdziwiłem jak można łatwo ubierać strony w jakieś natywne GUI. Poniższy skrypt jest zwykłym oknem przeglądarki opartej na gtkmozembed tyle, że potrafi schować się do ikonki w zasobniku systemowym dzięki czemu świetnie sprawuje się już jako odtwarzacz moich ulubionych utworów z Jamendo.
Przy pierwszym uruchomieniu należy się zalogować w serwisie (nowej wersji serwisu), a przy następnych od razu ładowany będzie ichniejszy player.
Skrypt: jtip.py
Odpalamy standardowo jak na pythona przystało:
$ python jtip.py
Oczywiście skrypt łatwo wykorzystać do obsługi innej strony.
BTW: Kiedy ktoś zrobi wtyczkę do QuodLibet obsługującą Jamendo ?
BTW2: Jak spowodować aby klikanie na krzyżyk chowało aplikację do ikonki w zasobniku? W moich próbach okno niby udało mi się ukryć nie wyłączając aplikacji, ale dźwięk się urywał a po kliknięciu na ikonkę w zasobniku przywracało się gołe okno.