SGJP / Kuznia

Zależności
----------

django-registration 0.7
django-extensions [dowolna wersja]

Takich paczek może się zrobić dużo i czasem mogą być potrzebne nowsze wersje, niż w repozytoriach dystrybucji, dlatego polecam zrobić w katalogu domowym podkatalog na te paczki (u mnie to jest ~/lib/python/) i instalować je programem easy_install w taki sposób:

$ easy_install --install-dir=~/lib/python/ -Z django-registration

Katalog z tymi paczkami powinien być w ścieżce Pythona, można o to zadbać np. dopisując do ~/.bashrc linijkę

export PYTHONPATH=$PYTHONPATH:~/lib/python/

UWAGA: niektóre skrypty należy na chopinie uruchamiać pod Pythonem 2.7, który na chopinie nie jest domyślnym Pythonem. Jeśli więc wywołanie jakiegoś skryptu zakończy się błędem, należy spróbować poprzedzić jego wywołanie przez 'python2.7', np.:

zamiast:
$ skrypt.py [argumenty]
piszemy:
$ python2.7 skrypt.py [argumenty]


Odpalenie serwera deweloperskiego
---------------------------------

Przede wszystkim trzeba skonfigurować bazę. W tym celu należy utworzyć plik o nazwie database_data.py w głównym katalogu projektu i wpisać w nim parametry bazy w poniższym formacie:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.', # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': '',                      # Or path to database file if using sqlite3.
        'USER': '',                      # Not used with sqlite3.
        'PASSWORD': '',                  # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

Ze względu na sortowanie a tergo, baza musi być w postgresie.
Potrzebny jest postgres w wersji co najmniej 9.1.
W konfiguracji postgresa (postgresql.conf) trzeba ustawić custom_variable_classes = 'var'.

Baza oczywiście na początku jest pusta. Można wgrać gotowy zrzut lub postąpić według dalszych instrukcji.

Tworzymy tabelę historii zmian:

$ ./manage.py dbshell < history/history_table.sql

(wszystkie polecenia mają być wykonywane w głównym katalogu projektu, o ile nie wskazano inaczej)

i pozostałe tabele:

$ ./manage.py syncdb

Pojawi się pytanie o utworzenie superusera, nie tworzymy go.

Poprawiamy więzy UNIQUE:

$ ./manage.py dbshell < sql/unique.sql

Następnie tworzymy standardowe klasyfikacje:

$ ./manage.py create_classifications

i role użytkowników:

$ ./manage.py create_groups

Teraz można uruchomić polecenie import_data, które bierze dane z bazy sqlite3 podanej w parametrze:

$ ./manage.py import_data baza.sqlite3

To trochę potrwa (od kilkunastu minut do pół godziny).
Teraz możemy utworzyć użytkowników:

$ ./manage.py create_users

Można też wygenerować formy (do filtrowania według form):

$ ./manage.py create_forms
(trochę potrwa - rzędu kilkunastu minut, pod warunkiem, że baza jest zvacuumowana)
(jeśli mamy zamiar importować inne dane, np. Morfologika, to można odpalić generowanie form po zaimportowaniu wszystkich)

Jeśli dotąd wszystko się udało, to możemy odpalić runserver:

$ ./manage.py runserver

i połączyć się z nim przez http://localhost:8000/.
Pojawi się ekran logowania, gdzie możemy wpisać login i identyczne z nim hasło któregoś z domyślnie zdefiniowanych użytkowników, np. sgjp.


Import danych z Morfologika
---------------------------

1.
Najpierw potrzebne są pliki odm.txt z http://www.sjp.pl/slownik/odmiany/ oraz morfologik-tools-[nr wersji].jar z http://sourceforge.net/projects/morfologik/files/morfologik-stemming/ (paczka morfologik-stemming-[nr wersji].zip). Potrzebny jest też program enconv z pakietu enca (powinien być w repozytoriach większości dystrybucji Linuksa).

Ścieżki do tych plików wpisujemy do skrypty/prepare_odm.sh do zmiennych 'odm' i 'morfologik'. Następnie uruchamiamy ten skrypt:

$ sh skrypty/prepare_odm.sh

i dostajemy plik to_disamb.txt. Ten plik należy przepuścić przez polecenie

$ ./manage.py disamb to_disamb.txt > disamb_result.txt 2> disamb_errors.txt

(drugi plik nie przyda się do automatycznego importu, ale będzie zawierał informacje o leksemach, które nie przeszły dezambiguacji). Z pliku disamb_result.txt odsiewamy następnie poszczególne części mowy:

$ skrypty/filter_forms.py subst disamb_result.txt > rzeczowniki-odm.txt
$ skrypty/filter_forms.py adj disamb_result.txt > przymiotniki-odm.txt
$ skrypty/filter_forms.py v disamb_result.txt > czasowniki-odm.txt
$ skrypty/filter_forms.py ndm disamb_result.txt > nieodmienne-odm.txt

2.
Część rozpoznanych przymiotników to w rzeczywistości nazwiska, które należy rozdzielić na męskie i żeńskie. Listę tych nazwisk powinniśmy mieć w pliku tekstowym, po jednym nazwisku na wiersz. Załóżmy, że mamy taki plik nazwiska.txt w aktualnym katalogu. Uruchamiamy

$ skrypty/wytnij_wiele.py nazwiska.txt < przymiotniki-odm.txt > nazwiska
$ skrypty/wytnij_wiele.py nazwiska.txt -r < przymiotniki-odm.txt > tmp && mv tmp przymiotniki-odm.txt
$ skrypty/podziel_nazwiska.sh nazwiska > nazwiska-odm.txt

Generujemy dane do importu [uwaga: tutaj musi być ustawione DEBUG = False w settings.py, inaczej zapycha się pamięć]:

$ ./manage.py import_morfologik subst rzeczowniki-odm.txt > rzeczowniki.json 2> rzeczowniki-failed.txt
$ ./manage.py import_morfologik subst nazwiska-odm.txt > nazwiska.json 2> nazwiska-failed.txt
$ ./manage.py import_morfologik adj przymiotniki-odm.txt > przymiotniki.json 2> przymiotniki-failed.txt
$ ./manage.py import_morfologik v czasowniki-odm.txt > czasowniki.json 2> czasowniki-failed.txt
$ ./manage.py import_morfologik ndm nieodmienne-odm.txt > nieodmienne.json 2> nieodmienne-failed.txt

[UWAGA: generowanie danych dla rzeczowników trwa ponad dobę na chopinie, dla czasowników i przymiotników po parę godzin, dla nieodmiennych poniżej godziny]

Część nierozpoznanych przymiotników powinna być tak naprawdę rozpoznana jako rzeczowniki. Takie rzeczowniki trafiają do przymiotniki-failed.txt z odpowiednim prefiksem. Wycinamy je poleceniem:

$ grep 'rzeczownik#' przymiotniki-failed.txt | cut -d'#' -f2 > rzeczowniki2-odm.txt

i generujemy dane do importu:

$ ./manage.py import_morfologik subst rzeczowniki2-odm.txt > rzeczowniki2.json 2> rzeczowniki2-failed.txt

3.
Teraz możemy wszystko załadować do bazy:

$ cat rzeczowniki.json rzeczowniki2.json nazwiska.json przymiotniki.json czasowniki.json nieodmienne.json > morfologik.json
$ ./manage.py load_morfologik morfologik.json 2> load_errors.txt

To potrwa (na chopinie ponad 5 godzin). Następnie warto poprawić wciągnięte dane. Kilka drobnych rzeczy poprawiamy przez

$ ./manage.py fix_morfologik

Następnie poprawiamy nazwiska z homonimami w SGJP błędnie oznaczone jako przymiotniki:

$ ./manage.py fix_surnames 2> surnames.log

i przerabiamy na 'osc' rzeczowniki oznaczające cechy, zaimportowane jako 'subst':

$ ./manage.py fix_osc 2> osc.log

Generowanie list do importu odsyłaczy:

[$ python gen/adjadv.py < gen/to_disamb.txt > advadj]
$ grep advadj gen/disamb_errors.txt | cut -d" " -f2- > advadj2
$ grep adv:comp gen/to_disamb.txt | cut -f1-2> advcom
$ grep adv:neg gen/to_disamb.txt | cut -f1-2 > advnie
$ python skrypty/adjadv.py < gen/to_disamb.txt > /dev/null 2> advnie2

Importowanie odsyłaczy:

$ ./manage.py extra_crs advcom advcom 2> advcom.log
$ ./manage.py extra_crs advadj advadj2 2> advadj.log
$ ./manage.py extra_crs advnie advnie 2> advnie.log
$ ./manage.py extra_crs advnie advnie2 2> advnie2.log
[$ ./manage.py extra_crs adjadvc advnie 2> adjadvc.log]

TODO
* przymiotniki Dzierżawcze
* podwójne dopasowania


TODO
* edycja tematu listu zapraszającego
* kompilowanie lokalizacji

Problemy
--------

Klawisze PageUp/PageDown działają (aktualnie przewijają na sztywno o 10, to można zmienić), ale przy włączonym zaznaczeniu i szybkim naciskaniu powodują, że czasem zaznaczenie ucieka. (okazuje się, że nawet całkiem często)