Tworzenie bazodanowych aplikacji desktopowych za pomocą frameworka Camelot
Camelot to framework do szybkiego tworzenia aplikacji desktopowych w oparciu o Pythona, Qt4 i SQLAlchemy. Framework ten celuje w aplikacje oparte o bazy danych - tam gdzie mamy kolekcje danych i chcemy nimi zarządzać (katalogi, zbiory różnych danych). Poważną konkurencją dla tego typu aplikacji desktopowych są aplikacje webowe, które dość często mogą okazać się prostsze lub tańsze do wykonania. W porównaniu do czystego PyQt4 framework daje nam gotowy szkielet oraz interfejs dla całej aplikacji (który dalej można rozszerzać i modyfikować). Oto jedna z prezentacji Camelota:
Instalacja Python-Camelot
Instalacja jest standardowa, wystarczy użyć pip:- Qt4
- PyQt
- SQLAlchemy
- Elixir
- sqlalchemy-migrate
- Jinja2
- chardet
- xlwt
- xlrd
Podstawowe elementy aplikacji
By stworzyć nową aplikację tworzymy pusty katalog i w nim wykonujemy polecenie:
Najważniejsza dla programisty jest nazwa modułu. W tym przypadku jest to "videostore". Po stworzeniu aplikacji w katalogu pojawi się parę plików i katalog o nazwie takiej jak nazwa modułu.
By uruchomić aplikację wystarczy wykonać:Lewa belka nawigacyjna zawiera w zakładkach "encje" przedstawiające tabele w bazie danych. Domyślnie mamy dwie - "Persons" i "Organisations". Każda zakładka jest sekcją.
Gdy z sekcji "relation" wybierzemy encję "Person" to pojawi nam się lista osób - lista rekordów zapisanych w tej tabeli. Na początku nie będzie żadnego. Możemy dodać nowe korzystając z górnego menu, które pojawia się wraz z wyborem encji:
Własne modele
Teraz przejdę przez proces tworzenia i konfiguracji modelu oraz sekcji. Tworząc aplikację będziemy musieli zdefiniować jakieś modele opisujące tabele w bazie danych.
Na początek można zajrzeć do settings.py, tam mamy zdefiniowane dane do bazy danych (create_engine). Domyślnie będzie to SQLite. Camelot używa SQLAlchemy do obsługi baz danych (i ew. nieco Elixira w modelach). Na potrzeby pierwszych testów nie trzeba nic tu zmieniać.
W katalogu videostore (nazwa naszego modułu) znajdziemy kilka ważnych plików. Pierwszy to model.py - zawiera on definicje naszych modeli. Drugi application_admin.py zawiera konfigurację sekcji - ile ich jest i jakie tabele (modele) zawierają.
Stwórzmy więc pierwszy model. Do models.py dodaj taki oto kod:from sqlalchemy import Unicode, Date
from elixir import Entity, Field, using_options
from camelot.admin.entity_admin import EntityAdmin
class Movie(Entity):
using_options(tablename='movie')
title = Field(Unicode(60), required=True)
short_description = Field(Unicode(512))
release_date = Field(Date)
genre = Field(Unicode(15))
class Admin(EntityAdmin):
verbose_name = 'Movie'
list_display = ['title', 'short_description', 'release_date', 'genre']
def __unicode__(self):
return self.title or 'untitled movie'
Mamy tutaj typowy model zdefiniowany za pomocą nakładki Elixir. Na początek określam własną nazwę dla tabeli, a następnie definiuję kolumny - tytuł, krótki opis, data premiery i kategorię filmu. Ten model definiuje samą tabelę. Czymś "nowym" jest klasa Admin (EntityAdmin) definiującej co i jak ma być wyświetlane w aplikacji. "verbose_name" określa nazwę encji wyświetlaną w aplikacji. "list_display" określa które kolumny mają być wyświetlane na liście wpisów. Zasady bardzo podobne do webowych frameworków (jak np. Django).
Teraz musimy umieścić nasz model w jakiejś sekcji. application_admin.py przechowuje listę sekcji i modele do nich przypisane. Oto zmodyfikowana lista sekcji zawierająca nową sekcję "Movies", a w niej nasz nowy model "Movie":
class MyApplicationAdmin(ApplicationAdmin):
name = 'Videostore'
application_url = 'http://www.python-camelot.com'
help_url = 'http://www.python-camelot.com/docs.html'
author = 'My Company'
domain = 'mydomain.com'
def get_sections(self):
from camelot.model.memento import Memento
from camelot.model.authentication import Person, Organization[rk:thumb src="python/camelot4b.png" alt="Dodawanie nowego wpisu"]
from camelot.model.i18n import Translation
# import model
from model import Movie
return [ Section( 'relation',
self,
Icon('tango/22x22/apps/system-users.png'),
items = [Person, Organization]),
Section( 'configuration',
self,
Icon('tango/22x22/categories/preferences-system.png'),
items = [Memento, Translation]),
# our new section
Section('Movies',
self,
Icon('tango/22x22/mimetypes/video-x-generic.png'),
items = [Movie])
]
Kolejnym ważnym elementem jest obsługa relacji między tabelami. SQLAlchemy, Elixir i Camelot je obsługują. Kasujemy plik bazy danych - model-data.sqlite i zmieniamy modele.
By stworzyć relację wystarczy użyć pól typu ManyToOne i OneToMany oferowany przez Elixira. Dla przykładu dodajmy model "Director" przechowujący reżyserów filmów:
from camelot.model import metadata
__metadata__ = metadata
from sqlalchemy import Unicode, Date
from elixir import Entity, Field, using_options
from camelot.admin.entity_admin import EntityAdmin
from elixir import ManyToOne, OneToMany
class Director(Entity):
using_options(tablename='director')
name = Field(Unicode(60))
movies = OneToMany('Movie')
class Admin(EntityAdmin):
verbose_name = 'Director'
list_display = ['name']
def __unicode__(self):
return self.name or 'unknown director'
class Movie(Entity):
using_options(tablename='movie')
title = Field(Unicode(60), required=True)
short_description = Field(Unicode(512))
release_date = Field(Date)
genre = Field(Unicode(15))
director = ManyToOne('Director')
class Admin(EntityAdmin):
verbose_name = 'Movie'
list_display = ['title', 'short_description', 'release_date', 'genre', 'director']
def __unicode__(self):
return self.title or 'untitled movie'
Comment article