zmiana formatowania, poprawka do dodawania zakończeń, ostrzeganie przed zamknięciem

janek37
1 parent 85716dbc
Showing 189 changed files with 53113 additions and 37346 deletions
accounts/ajax.py
accounts/forms.py
accounts/management/commands/create_groups.py
accounts/management/commands/create_users.py
accounts/management/commands/dummy_passwords.py
accounts/models.py
accounts/templates/manage_groups.html
accounts/templates/registration/activate.html
accounts/templates/registration/login.html
accounts/templates/registration/logout.html
accounts/templates/registration/password_change_done.html
accounts/templates/registration/password_change_form.html
accounts/templates/registration/password_reset_complete.html
accounts/templates/registration/password_reset_confirm.html
accounts/templates/registration/password_reset_done.html
accounts/templates/registration/password_reset_email.html
accounts/templates/registration/password_reset_form.html
accounts/templates/registration/registration_complete.html
accounts/templates/registration/registration_form.html
accounts/templates/settings.html
@@ -4,19 +4,21 @@ from django.contrib.auth.models import User, Group
 from common.decorators import ajax
 from dictionary.models import Vocabulary
  
+
 @ajax(method='post')
 def set_group(request, user_id, group_id, set):
-  user = User.objects.get(pk=user_id)
-  group = Group.objects.get(pk=group_id)
-  if set:
-    user.groups.add(group)
-  else:
-    user.groups.remove(group)
-  return {}
+    user = User.objects.get(pk=user_id)
+    group = Group.objects.get(pk=group_id)
+    if set:
+        user.groups.add(group)
+    else:
+        user.groups.remove(group)
+    return {}
+
  
 @ajax(method='post')
 def save_default_owner(request, vocab_id):
-  us = request.user.usersettings
-  us.default_owner = Vocabulary.objects.get(pk=vocab_id)
-  us.save()
-  return {}
+    us = request.user.usersettings
+    us.default_owner = Vocabulary.objects.get(pk=vocab_id)
+    us.save()
+    return {}
@@ -3,35 +3,38 @@
 import random
 import string
 from django.forms import *
-from django.utils.translation import ugettext_lazy as _
 from django.contrib.auth.forms import PasswordResetForm
 from django.contrib.auth.models import User
 from accounts.models import UserSettings
  
+
 class AddUserForm(ModelForm):
-  def save(self, commit=True, request=None):
-    user = super(AddUserForm, self).save(commit=False)
-    password = ''.join(random.choice(string.printable) for i in range(32))
-    user.set_password(password)
-    if commit:
-      user.save()
-    fakeform = PasswordResetForm(data={'email': user.email})
-    if fakeform.is_valid(): # oczywiście, że jest
-      fakeform.save(request=request)
-    UserSettings.objects.create(user=user)
-    user.groups.add(*self.cleaned_data['groups'])
-    return user
-  class Meta:
-    model = User
-    fields = ['username', 'first_name', 'last_name', 'email', 'groups']
+    def save(self, commit=True, request=None):
+        user = super(AddUserForm, self).save(commit=False)
+        password = ''.join(random.choice(string.printable) for i in range(32))
+        user.set_password(password)
+        if commit:
+            user.save()
+        fakeform = PasswordResetForm(data={'email': user.email})
+        if fakeform.is_valid(): # oczywiście, że jest
+            fakeform.save(request=request)
+        UserSettings.objects.create(user=user)
+        user.groups.add(*self.cleaned_data['groups'])
+        return user
+
+    class Meta:
+        model = User
+        fields = ['username', 'first_name', 'last_name', 'email', 'groups']
+
  
 class SettingsForm(ModelForm):
-  def __init__(self, vocabularies=None, **kwargs):
-    super(SettingsForm, self).__init__(**kwargs)
-    if vocabularies:
-      self.fields['default_owner'].queryset = vocabularies
-    else:
-      self.fields['default_owner'].widget = HiddenInput()
-  class Meta:
-    model = UserSettings
-    fields = ['incremental_search', 'filter_search', 'default_owner']
+    def __init__(self, vocabularies=None, **kwargs):
+        super(SettingsForm, self).__init__(**kwargs)
+        if vocabularies:
+            self.fields['default_owner'].queryset = vocabularies
+        else:
+            self.fields['default_owner'].widget = HiddenInput()
+
+    class Meta:
+        model = UserSettings
+        fields = ['incremental_search', 'filter_search', 'default_owner']
 #-*- coding:utf-8 -*-
  
 from django.contrib.auth.models import Permission, Group
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import BaseCommand
+
  
 class Command(BaseCommand):
-  args = 'none'
-  help = 'Creates default groups'
+    args = 'none'
+    help = 'Creates default groups'
  
-  def handle(self, **options):
-    create_groups()
+    def handle(self, **options):
+        create_groups()
  
  
 def get_permission(codename):
-  return Permission.objects.get(codename=codename)
+    return Permission.objects.get(codename=codename)
+
  
 def create_groups():
-  Group.objects.all().delete()
-  observers = Group.objects.create(name=u'Obserwator')
-  lexicographers = Group.objects.create(name=u'Leksykograf')
-  superlexicographers = Group.objects.create(name=u'Superleksykograf')
-  patternmakers = Group.objects.create(name=u'Wzorzysta')
-  managers = Group.objects.create(name=u'Wydawca')
-  admins = Group.objects.create(name=u'Administrator')
-
-  observers.permissions.add(get_permission('view_lexeme'))
-  #observers.permissions.add(get_permission('add_comment'))
-  observers.permissions.add(get_permission('view_pattern'))
-  lexicographers.permissions.add(get_permission('view_lexeme'))
-  lexicographers.permissions.add(get_permission('change_lexeme'))
-  lexicographers.permissions.add(get_permission('export_lexemes'))
-  lexicographers.permissions.add(get_permission('view_pattern'))
-  superlexicographers.permissions.add(get_permission('view_lexeme'))
-  superlexicographers.permissions.add(get_permission('change_lexeme'))
-  superlexicographers.permissions.add(get_permission('export_lexemes'))
-  superlexicographers.permissions.add(get_permission('lexeme_priority'))
-  superlexicographers.permissions.add(get_permission('view_pattern'))
-  # może dokonywać zmian w Banku błędów
-  # może dokonywać zmian w zakładce Etykiety
-  patternmakers.permissions.add(get_permission('view_pattern'))
-  patternmakers.permissions.add(get_permission('change_pattern'))
-  managers.permissions.add(get_permission('manage_vocabulary'))
-  managers.permissions.add(get_permission('view_lexeme'))
-  managers.permissions.add(get_permission('view_all_lexemes'))
-  managers.permissions.add(get_permission('view_pattern'))
-  managers.permissions.add(get_permission('add_user'))
-  managers.permissions.add(get_permission('export_lexemes'))
-  # zarządzanie rolami użytkowników:
-  managers.permissions.add(get_permission('change_group'))
-  admins.permissions.add(get_permission('add_user'))
-  admins.permissions.add(get_permission('change_group'))
-  admins.permissions.add(get_permission('create_admin'))
-  admins.permissions.add(get_permission('manage_vocabulary'))
-  admins.permissions.add(get_permission('manage_all_vocabularies'))
+    Group.objects.all().delete()
+    observers = Group.objects.create(name=u'Obserwator')
+    lexicographers = Group.objects.create(name=u'Leksykograf')
+    superlexicographers = Group.objects.create(name=u'Superleksykograf')
+    patternmakers = Group.objects.create(name=u'Wzorzysta')
+    managers = Group.objects.create(name=u'Wydawca')
+    admins = Group.objects.create(name=u'Administrator')
+
+    observers.permissions.add(get_permission('view_lexeme'))
+    #observers.permissions.add(get_permission('add_comment'))
+    observers.permissions.add(get_permission('view_pattern'))
+    lexicographers.permissions.add(get_permission('view_lexeme'))
+    lexicographers.permissions.add(get_permission('change_lexeme'))
+    lexicographers.permissions.add(get_permission('export_lexemes'))
+    lexicographers.permissions.add(get_permission('view_pattern'))
+    superlexicographers.permissions.add(get_permission('view_lexeme'))
+    superlexicographers.permissions.add(get_permission('change_lexeme'))
+    superlexicographers.permissions.add(get_permission('export_lexemes'))
+    superlexicographers.permissions.add(get_permission('lexeme_priority'))
+    superlexicographers.permissions.add(get_permission('view_pattern'))
+    # może dokonywać zmian w Banku błędów
+    # może dokonywać zmian w zakładce Etykiety
+    patternmakers.permissions.add(get_permission('view_pattern'))
+    patternmakers.permissions.add(get_permission('change_pattern'))
+    managers.permissions.add(get_permission('manage_vocabulary'))
+    managers.permissions.add(get_permission('view_lexeme'))
+    managers.permissions.add(get_permission('view_all_lexemes'))
+    managers.permissions.add(get_permission('view_pattern'))
+    managers.permissions.add(get_permission('add_user'))
+    managers.permissions.add(get_permission('export_lexemes'))
+    # zarządzanie rolami użytkowników:
+    managers.permissions.add(get_permission('change_group'))
+    admins.permissions.add(get_permission('add_user'))
+    admins.permissions.add(get_permission('change_group'))
+    admins.permissions.add(get_permission('create_admin'))
+    admins.permissions.add(get_permission('manage_vocabulary'))
+    admins.permissions.add(get_permission('manage_all_vocabularies'))
@@ -5,92 +5,97 @@ from django.core.management.base import BaseCommand, CommandError
 from dictionary.models import Vocabulary
 from accounts.models import UserSettings
  
+
 class Command(BaseCommand):
-  args = 'none'
-  help = 'Creates default users'
+    args = 'none'
+    help = 'Creates default users'
  
-  def handle(self, **options):
-    create_users()
+    def handle(self, **options):
+        create_users()
  
  
 def create_users():
-  observers = Group.objects.get(name=u'Obserwator')
-  lexicographers = Group.objects.get(name=u'Leksykograf')
-  superlexicographers = Group.objects.get(name=u'Superleksykograf')
-  patternmakers = Group.objects.get(name=u'Wzorzysta')
-  managers = Group.objects.get(name=u'Wydawca')
-  admins = Group.objects.get(name=u'Administrator')
-
-  SGJP = Vocabulary.objects.get(id='SGJP')
-  SJPDor = Vocabulary.objects.get(id='SJPDor')
-  zmiotki = Vocabulary.objects.get(id='zmiotki')
-  try:
-    WSJP = Vocabulary.objects.get(id='WSJP')
-  except Vocabulary.DoesNotExist:
-    WSJP = None
-  Morfologik, created = Vocabulary.objects.get_or_create(id='Morfologik')
-  PoliMorf, created = Vocabulary.objects.get_or_create(id='PoliMorf')
-
-  User.objects.all().delete()
-  sgjp = User.objects.create_user('sgjp', 'sgjp@example.com', 'sgjp')
-  nzm = User.objects.create_user('nzm', 'nzm@example.com', 'nzm')
-  redsgjp = User.objects.create_user('redsgjp', 'redsgjp@example.com', 'redsgjp')
-  rednzm = User.objects.create_user('rednzm', 'rednzm@example.com', 'rednzm')
-  supersgjp = User.objects.create_user('supersgjp', 'supersgjp@example.com', 'supersgjp')
-  supernzm = User.objects.create_user('supernzm', 'supernzm@example.com', 'supernzm')
-  wzornik = User.objects.create_user('wzornik', 'wzornik@example.com', 'wzornik')
-  admin = User.objects.create_user('admin', 'admin@example.com', 'admin')
-
-  users = (sgjp, nzm, redsgjp, rednzm, supersgjp, supernzm, wzornik, admin)
-  for user in users:
-    UserSettings.objects.create(user=user)
-
-  admin.groups.add(admins)
-
-  sgjp_vocabs = (SGJP, SJPDor, zmiotki)
-  if WSJP: sgjp_vocabs += (WSJP,)
-  nzm_vocabs = (zmiotki, Morfologik, PoliMorf)
-
-  sgjp.groups.add(managers)
-  for vocab in sgjp_vocabs:
-    sgjp.managed_vocabularies.add(vocab)
-  nzm.groups.add(managers)
-  for vocab in nzm_vocabs:
-    nzm.managed_vocabularies.add(vocab)
-
-  redsgjp.groups.add(lexicographers)
-  for vocab in sgjp_vocabs:
-    redsgjp.visible_vocabularies.add(vocab)
-    redsgjp.editable_vocabularies.add(vocab)
-  redsgjp.visible_vocabularies.add(PoliMorf)
-
-  rednzm.groups.add(lexicographers)
-  for vocab in nzm_vocabs:
-    rednzm.visible_vocabularies.add(vocab)
-    rednzm.editable_vocabularies.add(vocab)
-  rednzm.visible_vocabularies.add(SGJP)
-  if WSJP:
-    rednzm.visible_vocabularies.add(WSJP)
-  rednzm.visible_vocabularies.add(SJPDor)
-
-  supersgjp.groups.add(superlexicographers)
-  for vocab in sgjp_vocabs:
-    supersgjp.visible_vocabularies.add(vocab)
-    supersgjp.editable_vocabularies.add(vocab)
-  supersgjp.visible_vocabularies.add(PoliMorf)
-
-  supernzm.groups.add(superlexicographers)
-  for vocab in nzm_vocabs:
-    supernzm.visible_vocabularies.add(vocab)
-    supernzm.editable_vocabularies.add(vocab)
-  supernzm.visible_vocabularies.add(SGJP)
-  if WSJP:
-    supernzm.visible_vocabularies.add(WSJP)
-  supernzm.visible_vocabularies.add(SJPDor)
-
-  wzornik.groups.add(superlexicographers)
-  for vocab in sgjp_vocabs:
-    wzornik.visible_vocabularies.add(vocab)
-    wzornik.editable_vocabularies.add(vocab)
-  wzornik.visible_vocabularies.add(PoliMorf)
-  wzornik.groups.add(patternmakers)
+    observers = Group.objects.get(name=u'Obserwator')
+    lexicographers = Group.objects.get(name=u'Leksykograf')
+    superlexicographers = Group.objects.get(name=u'Superleksykograf')
+    patternmakers = Group.objects.get(name=u'Wzorzysta')
+    managers = Group.objects.get(name=u'Wydawca')
+    admins = Group.objects.get(name=u'Administrator')
+
+    SGJP = Vocabulary.objects.get(id='SGJP')
+    SJPDor = Vocabulary.objects.get(id='SJPDor')
+    zmiotki = Vocabulary.objects.get(id='zmiotki')
+    try:
+        WSJP = Vocabulary.objects.get(id='WSJP')
+    except Vocabulary.DoesNotExist:
+        WSJP = None
+    Morfologik, created = Vocabulary.objects.get_or_create(id='Morfologik')
+    PoliMorf, created = Vocabulary.objects.get_or_create(id='PoliMorf')
+
+    User.objects.all().delete()
+    sgjp = User.objects.create_user('sgjp', 'sgjp@example.com', 'sgjp')
+    nzm = User.objects.create_user('nzm', 'nzm@example.com', 'nzm')
+    redsgjp = User.objects.create_user('redsgjp', 'redsgjp@example.com',
+                                       'redsgjp')
+    rednzm = User.objects.create_user('rednzm', 'rednzm@example.com', 'rednzm')
+    supersgjp = User.objects.create_user('supersgjp', 'supersgjp@example.com',
+                                         'supersgjp')
+    supernzm = User.objects.create_user('supernzm', 'supernzm@example.com',
+                                        'supernzm')
+    wzornik = User.objects.create_user('wzornik', 'wzornik@example.com',
+                                       'wzornik')
+    admin = User.objects.create_user('admin', 'admin@example.com', 'admin')
+
+    users = (sgjp, nzm, redsgjp, rednzm, supersgjp, supernzm, wzornik, admin)
+    for user in users:
+        UserSettings.objects.create(user=user)
+
+    admin.groups.add(admins)
+
+    sgjp_vocabs = (SGJP, SJPDor, zmiotki)
+    if WSJP: sgjp_vocabs += (WSJP,)
+    nzm_vocabs = (zmiotki, Morfologik, PoliMorf)
+
+    sgjp.groups.add(managers)
+    for vocab in sgjp_vocabs:
+        sgjp.managed_vocabularies.add(vocab)
+    nzm.groups.add(managers)
+    for vocab in nzm_vocabs:
+        nzm.managed_vocabularies.add(vocab)
+
+    redsgjp.groups.add(lexicographers)
+    for vocab in sgjp_vocabs:
+        redsgjp.visible_vocabularies.add(vocab)
+        redsgjp.editable_vocabularies.add(vocab)
+    redsgjp.visible_vocabularies.add(PoliMorf)
+
+    rednzm.groups.add(lexicographers)
+    for vocab in nzm_vocabs:
+        rednzm.visible_vocabularies.add(vocab)
+        rednzm.editable_vocabularies.add(vocab)
+    rednzm.visible_vocabularies.add(SGJP)
+    if WSJP:
+        rednzm.visible_vocabularies.add(WSJP)
+    rednzm.visible_vocabularies.add(SJPDor)
+
+    supersgjp.groups.add(superlexicographers)
+    for vocab in sgjp_vocabs:
+        supersgjp.visible_vocabularies.add(vocab)
+        supersgjp.editable_vocabularies.add(vocab)
+    supersgjp.visible_vocabularies.add(PoliMorf)
+
+    supernzm.groups.add(superlexicographers)
+    for vocab in nzm_vocabs:
+        supernzm.visible_vocabularies.add(vocab)
+        supernzm.editable_vocabularies.add(vocab)
+    supernzm.visible_vocabularies.add(SGJP)
+    if WSJP:
+        supernzm.visible_vocabularies.add(WSJP)
+    supernzm.visible_vocabularies.add(SJPDor)
+
+    wzornik.groups.add(superlexicographers)
+    for vocab in sgjp_vocabs:
+        wzornik.visible_vocabularies.add(vocab)
+        wzornik.editable_vocabularies.add(vocab)
+    wzornik.visible_vocabularies.add(PoliMorf)
+    wzornik.groups.add(patternmakers)
@@ -3,15 +3,16 @@
 from django.contrib.auth.models import User
 from django.core.management.base import BaseCommand
  
+
 class Command(BaseCommand):
-  args = 'none'
-  help = 'Sets dummy passwords'
+    args = 'none'
+    help = 'Sets dummy passwords'
  
-  def handle(self, **options):
-    dummy_passwords()
+    def handle(self, **options):
+        dummy_passwords()
  
  
 def dummy_passwords():
-  for user in User.objects.all():
-    user.set_password(user.username)
-    user.save()
 \ No newline at end of file
+    for user in User.objects.all():
+        user.set_password(user.username)
+        user.save()
 \ No newline at end of file
@@ -6,45 +6,48 @@ from dictionary.models import Vocabulary
  
 MANAGER_GROUPS = ('Obserwator', 'Leksykograf', 'Superleksykograf')
  
+
 def manager_groups():
-  return Group.objects.filter(name__in=MANAGER_GROUPS)
+    return Group.objects.filter(name__in=MANAGER_GROUPS)
+
  
 class UserSettings(Model):
-  user = OneToOneField(User)
-  incremental_search = BooleanField(
-    default=True,
-    verbose_name=u'wyszukiwanie przyrostowe',
-    help_text=u'Wyszukiwanie odbywa się automatycznie w miarę wpisywania '
-              u'szukanego hasła. Sugerujemy wyłączenie w wypadku wolnego '
-              u'połączenia internetowego.')
-  filter_search = BooleanField(
-    default=False,
-    verbose_name=u'wyszukiwanie przez filtrowanie',
-    help_text=u'Wyszukiwanie powoduje zawężenie listy haseł do pasujących '
-              u'do zapytania.')
-  default_owner = ForeignKey(
-    Vocabulary, blank=True, null=True,
-    verbose_name=u'domyślny słownik właściciel dodawanych leksemów')
-
-  def views_lexeme(self):
-    return self.user.has_perm('dictionary.view_lexeme')
-
-  def views_all_lexemes(self):
-    return self.user.has_perm('dictionary.view_all_lexemes')
-
-  def changes_lexeme(self):
-    return self.user.has_perm('dictionary.change_lexeme')
-
-  def manages_vocabulary(self):
-    return self.user.has_perm('dictionary.manage_vocabulary')
-
-  def manages_all_vocabs(self):
-    return self.user.has_perm('dictionary.manage_all_vocabularies')
-
-  class Meta:
-    permissions = (
-      ('create_admin', u'Może nadawać dowolne role'),
-    )
+    user = OneToOneField(User)
+    incremental_search = BooleanField(
+        default=True,
+        verbose_name=u'wyszukiwanie przyrostowe',
+        help_text=u'Wyszukiwanie odbywa się automatycznie w miarę wpisywania '
+                  u'szukanego hasła. Sugerujemy wyłączenie w wypadku wolnego '
+                  u'połączenia internetowego.')
+    filter_search = BooleanField(
+        default=False,
+        verbose_name=u'wyszukiwanie przez filtrowanie',
+        help_text=u'Wyszukiwanie powoduje zawężenie listy haseł do pasujących '
+                  u'do zapytania.')
+    default_owner = ForeignKey(
+        Vocabulary, blank=True, null=True,
+        verbose_name=u'domyślny słownik właściciel dodawanych leksemów')
+
+    def views_lexeme(self):
+        return self.user.has_perm('dictionary.view_lexeme')
+
+    def views_all_lexemes(self):
+        return self.user.has_perm('dictionary.view_all_lexemes')
+
+    def changes_lexeme(self):
+        return self.user.has_perm('dictionary.change_lexeme')
+
+    def manages_vocabulary(self):
+        return self.user.has_perm('dictionary.manage_vocabulary')
+
+    def manages_all_vocabs(self):
+        return self.user.has_perm('dictionary.manage_all_vocabularies')
+
+    class Meta:
+        permissions = (
+            ('create_admin', u'Może nadawać dowolne role'),
+        )
+
  
 def filtering_mode(user):
-  return user.usersettings.filter_search
+    return user.usersettings.filter_search
@@ -2,32 +2,33 @@
 {% load ingroup %}
  
 {% block extrahead %}
-  <script type="text/javascript" src="{{ MEDIA_URL }}js/manage-groups.js"></script>
+    <script type="text/javascript"
+            src="{{ MEDIA_URL }}js/manage-groups.js"></script>
 {% endblock %}
  
 {% block title %}Role użytkowników{% endblock %}
  
 {% block content %}
-  <h3>Role użytkowników</h3>
-  <table id="user-groups">
-    <tr>
-      <th>nazwa</th>
-      {% for group in groups %}
-        <th>{{ group.name }}</th>
-      {% endfor %}
-    </tr>
-    {% for u in users %}
-      <tr>
-        <td>{{ u.username }}</td>
-        {% for group in groups %}
-          <td>
-            <input
-              type="checkbox"
-              id="group-{{ group.pk }}-{{ u.pk }}"
-              {% if u|ingroup:group %}checked="checked"{% endif %}/>
-          </td>
+    <h3>Role użytkowników</h3>
+    <table id="user-groups">
+        <tr>
+            <th>nazwa</th>
+            {% for group in groups %}
+                <th>{{ group.name }}</th>
+            {% endfor %}
+        </tr>
+        {% for u in users %}
+            <tr>
+                <td>{{ u.username }}</td>
+                {% for group in groups %}
+                    <td>
+                        <input
+                                type="checkbox"
+                                id="group-{{ group.pk }}-{{ u.pk }}"
+                                {% if u|ingroup:group %}checked="checked"{% endif %}/>
+                    </td>
+                {% endfor %}
+            </tr>
         {% endfor %}
-      </tr>
-    {% endfor %}
-  </table>
+    </table>
 {% endblock %}
@@ -4,10 +4,11 @@
  
 {% block content %}
  
-{% blocktrans %}
-<h1>Activation</h1>
-<p>Your account is now activated. Go <a href="{% url 'main' %}">here</a> to continue.</p>
+    {% blocktrans %}
+        <h1>Activation</h1>
+        <p>Your account is now activated. Go <a href="{% url 'main' %}">here</a>
+            to continue.</p>
  
-{% endblocktrans %}
+    {% endblocktrans %}
  
 {% endblock %}
@@ -3,32 +3,35 @@
 {% load url from future %}
  
 {% block content %}
-{% if form.errors and not form.non_field_errors and not form.this_is_the_login_form.errors %}
-<p class="errornote">
-{% blocktrans count form.errors.items|length as counter %}Please correct the error below.{% plural %}Please correct the errors below.{% endblocktrans %}
-</p>
-{% endif %}
+    {% if form.errors and not form.non_field_errors and not form.this_is_the_login_form.errors %}
+        <p class="errornote">
+            {% blocktrans count form.errors.items|length as counter %}Please
+                correct the error below.{% plural %}Please correct the errors
+                below.{% endblocktrans %}
+        </p>
+    {% endif %}
  
-{% if form.non_field_errors or form.this_is_the_login_form.errors %}
-{% for error in form.non_field_errors|add:form.this_is_the_login_form.errors %}
-<p class="errornote">
-    {{ error }}
-</p>
-{% endfor %}
-{% endif %}
+    {% if form.non_field_errors or form.this_is_the_login_form.errors %}
+        {% for error in form.non_field_errors|add:form.this_is_the_login_form.errors %}
+            <p class="errornote">
+                {{ error }}
+            </p>
+        {% endfor %}
+    {% endif %}
  
-<div id="content-main">
-<form action="" method="post" id="login-form">{% csrf_token %}
-  {{ form.as_p }}
-  <div class="submit-row">
-    <label>&nbsp;</label><input type="submit" value="{% trans 'Log in' %}" />
-  </div>
-</form>
+    <div id="content-main">
+        <form action="" method="post" id="login-form">{% csrf_token %}
+            {{ form.as_p }}
+            <div class="submit-row">
+                <label>&nbsp;</label><input type="submit"
+                                            value="{% trans 'Log in' %}"/>
+            </div>
+        </form>
  
-<a href="{% url 'auth_password_reset' %}">Nie pamiętam hasła</a>
+        <a href="{% url 'auth_password_reset' %}">Nie pamiętam hasła</a>
  
-<script type="text/javascript">
-document.getElementById('id_username').focus()
-</script>
-</div>
+        <script type="text/javascript">
+            document.getElementById('id_username').focus()
+        </script>
+    </div>
 {% endblock %}
@@ -4,8 +4,8 @@
  
 {% block content %}
  
-<p>{% trans "Thanks for spending some quality time with the Web site today." %}</p>
+    <p>{% trans "Thanks for spending some quality time with the Web site today." %}</p>
  
-<p><a href="{% url 'auth_login' %}">{% trans 'Log in again' %}</a></p>
+    <p><a href="{% url 'auth_login' %}">{% trans 'Log in again' %}</a></p>
  
 {% endblock %}
@@ -2,14 +2,15 @@
 {% load i18n %}
 {% load url from future %}
  
-{% block userlinks %}{% trans 'Change password' %} / <a href="{{ url 'auth_logout' }}">{% trans 'Log out' %}</a>{% endblock %}
+{% block userlinks %}{% trans 'Change password' %} /
+    <a href="{{ url 'auth_logout' }}">{% trans 'Log out' %}</a>{% endblock %}
  
 {% block title %}{% trans 'Password change successful' %}{% endblock %}
  
 {% block content %}
  
-<h1>{% trans 'Password change successful' %}</h1>
+    <h1>{% trans 'Password change successful' %}</h1>
  
-<p>{% trans 'Your password was changed.' %}</p>
+    <p>{% trans 'Your password was changed.' %}</p>
  
 {% endblock %}
 {% extends "base.html" %}
 {% load i18n %}
 {% load url from future %}
-{% block userlinks %}{% trans 'Change password' %} / <a href="{% url 'auth_logout' %}">{% trans 'Log out' %}</a>{% endblock %}
+{% block userlinks %}{% trans 'Change password' %} /
+    <a href="{% url 'auth_logout' %}">{% trans 'Log out' %}</a>{% endblock %}
  
 {% block title %}{% trans 'Password change' %}{% endblock %}
  
-{% block content %}<div id="content-main">
-
-<form action="" method="post">{% csrf_token %}
-<div>
-{% if form.errors %}
-    <p class="errornote">
-    {% blocktrans count form.errors.items|length as counter %}Please correct the error below.{% plural %}Please correct the errors below.{% endblocktrans %}
-    </p>
-{% endif %}
-
-<h1>{% trans 'Password change' %}</h1>
-
-<p>{% trans "Please enter your old password, for security's sake, and then enter your new password twice so we can verify you typed it in correctly." %}</p>
-
-<fieldset class="module aligned wide">
-
-<div class="form-row">
-    {{ form.old_password.errors }}
-    <label for="id_old_password" class="required">{% trans 'Old password' %}:</label>{{ form.old_password }}
-</div>
-
-<div class="form-row">
-    {{ form.new_password1.errors }}
-    <label for="id_new_password1" class="required">{% trans 'New password' %}:</label>{{ form.new_password1 }}
-</div>
-
-<div class="form-row">
-{{ form.new_password2.errors }}
-    <label for="id_new_password2" class="required">{% trans 'Password (again)' %}:</label>{{ form.new_password2 }}
-</div>
-
-</fieldset>
-
-<div class="submit-row">
-    <input type="submit" value="{% trans 'Change my password' %}" class="default" />
-</div>
-
-<script type="text/javascript">document.getElementById("id_old_password").focus();</script>
-</div>
-</form></div>
+{% block content %}
+    <div id="content-main">
+
+    <form action="" method="post">{% csrf_token %}
+        <div>
+            {% if form.errors %}
+                <p class="errornote">
+                    {% blocktrans count form.errors.items|length as counter %}
+                        Please correct the error below.{% plural %}Please
+                        correct the errors below.{% endblocktrans %}
+                </p>
+            {% endif %}
+
+            <h1>{% trans 'Password change' %}</h1>
+
+            <p>{% trans "Please enter your old password, for security's sake, and then enter your new password twice so we can verify you typed it in correctly." %}</p>
+
+            <fieldset class="module aligned wide">
+
+                <div class="form-row">
+                    {{ form.old_password.errors }}
+                    <label for="id_old_password"
+                           class="required">{% trans 'Old password' %}:</label>{{ form.old_password }}
+                </div>
+
+                <div class="form-row">
+                    {{ form.new_password1.errors }}
+                    <label for="id_new_password1"
+                           class="required">{% trans 'New password' %}:</label>{{ form.new_password1 }}
+                </div>
+
+                <div class="form-row">
+                    {{ form.new_password2.errors }}
+                    <label for="id_new_password2"
+                           class="required">{% trans 'Password (again)' %}:</label>{{ form.new_password2 }}
+                </div>
+
+            </fieldset>
+
+            <div class="submit-row">
+                <input type="submit" value="{% trans 'Change my password' %}"
+                       class="default"/>
+            </div>
+
+            <script type="text/javascript">document.getElementById("id_old_password").focus();</script>
+        </div>
+    </form></div>
  
 {% endblock %}
@@ -5,10 +5,10 @@
  
 {% block content %}
  
-<h1>{% trans 'Password reset complete' %}</h1>
+    <h1>{% trans 'Password reset complete' %}</h1>
  
-<p>{% trans "Your password has been set.  You may go ahead and log in now." %}</p>
+    <p>{% trans "Your password has been set.  You may go ahead and log in now." %}</p>
  
-<p><a href="{{ login_url }}">{% trans 'Log in' %}</a></p>
+    <p><a href="{{ login_url }}">{% trans 'Log in' %}</a></p>
  
 {% endblock %}
@@ -5,26 +5,32 @@
  
 {% block content %}
  
-{% if validlink %}
+    {% if validlink %}
  
-<h1>{% trans 'Enter new password' %}</h1>
+        <h1>{% trans 'Enter new password' %}</h1>
  
-<p>{% trans "Please enter your new password twice so we can verify you typed it in correctly." %}</p>
+        <p>{% trans "Please enter your new password twice so we can verify you typed it in correctly." %}</p>
  
-<form action="" method="post">{% csrf_token %}
-{{ form.new_password1.errors }}
-<p class="aligned wide"><label for="id_new_password1">{% trans 'New password:' %}</label>{{ form.new_password1 }}</p>
-{{ form.new_password2.errors }}
-<p class="aligned wide"><label for="id_new_password2">{% trans 'Confirm password:' %}</label>{{ form.new_password2 }}</p>
-<p><input type="submit" value="{% trans 'Change my password' %}" /></p>
-</form>
+        <form action="" method="post">{% csrf_token %}
+            {{ form.new_password1.errors }}
+            <p class="aligned wide"><label
+                    for="id_new_password1">{% trans 'New password:' %}</label>{{ form.new_password1 }}
+            </p>
+            {{ form.new_password2.errors }}
+            <p class="aligned wide"><label
+                    for="id_new_password2">{% trans 'Confirm password:' %}</label>{{ form.new_password2 }}
+            </p>
  
-{% else %}
+            <p><input type="submit" value="{% trans 'Change my password' %}"/>
+            </p>
+        </form>
  
-<h1>{% trans 'Password reset unsuccessful' %}</h1>
+    {% else %}
  
-<p>{% trans "The password reset link was invalid, possibly because it has already been used.  Please request a new password reset." %}</p>
+        <h1>{% trans 'Password reset unsuccessful' %}</h1>
  
-{% endif %}
+        <p>{% trans "The password reset link was invalid, possibly because it has already been used.  Please request a new password reset." %}</p>
+
+    {% endif %}
  
 {% endblock %}
@@ -5,8 +5,8 @@
  
 {% block content %}
  
-<h1>{% trans 'Password reset successful' %}</h1>
+    <h1>{% trans 'Password reset successful' %}</h1>
  
-<p>{% trans "We've e-mailed you instructions for setting your password to the e-mail address you submitted. You should be receiving it shortly." %}</p>
+    <p>{% trans "We've e-mailed you instructions for setting your password to the e-mail address you submitted. You should be receiving it shortly." %}</p>
  
 {% endblock %}
 {% load i18n %}{% load url from future %}{% autoescape off %}
  
-Szanowny Użytkowniku!
+    Szanowny Użytkowniku!
  
-Ten list jest częścią procedury ustanawiania lub zmiany hasła w systemie Kuźnia.
-Jeżeli fakt, że masz konto w systemie Kuźnia jest dla Ciebie
-zaskoczeniem, zechciej ten list uznać za doniesienie, że właśnie
-założyliśmy Ci konto.
+    Ten list jest częścią procedury ustanawiania lub zmiany hasła w systemie
+    Kuźnia.
+    Jeżeli fakt, że masz konto w systemie Kuźnia jest dla Ciebie
+    zaskoczeniem, zechciej ten list uznać za doniesienie, że właśnie
+    założyliśmy Ci konto.
  
-Aby wprowadzić nowe hasło, przejdź na następującą stronę:
-{% block reset_link %}
-{{ protocol }}://{{ domain }}{% url 'django.contrib.auth.views.password_reset_confirm' uidb36=uid token=token %}
-{% endblock %}
+    Aby wprowadzić nowe hasło, przejdź na następującą stronę:
+    {% block reset_link %}
+        {{ protocol }}://
+        {{ domain }}{% url 'django.contrib.auth.views.password_reset_confirm' uidb36=uid token=token %}
+    {% endblock %}
  
-Twoja nazwa użytkownika: {{ user.username }}
+    Twoja nazwa użytkownika: {{ user.username }}
  
-Z wyrazami szacunku
-Zespół Kuźni
+    Z wyrazami szacunku
+    Zespół Kuźni
 {% endautoescape %}
@@ -5,13 +5,15 @@
  
 {% block content %}
  
-<h1>{% trans "Password reset" %}</h1>
+    <h1>{% trans "Password reset" %}</h1>
  
-<p>{% trans "Forgotten your password? Enter your e-mail address below, and we'll e-mail instructions for setting a new one." %}</p>
+    <p>{% trans "Forgotten your password? Enter your e-mail address below, and we'll e-mail instructions for setting a new one." %}</p>
  
-<form action="" method="post">{% csrf_token %}
-{{ form.email.errors }}
-<p><label for="id_email">{% trans 'E-mail address:' %}</label> {{ form.email }} <input type="submit" value="{% trans 'Reset my password' %}" /></p>
-</form>
+    <form action="" method="post">{% csrf_token %}
+        {{ form.email.errors }}
+        <p><label
+                for="id_email">{% trans 'E-mail address:' %}</label> {{ form.email }}
+            <input type="submit" value="{% trans 'Reset my password' %}"/></p>
+    </form>
  
 {% endblock %}
@@ -3,9 +3,10 @@
  
 {% block content %}
  
-{% blocktrans %}
-<h1>Thank you</h1>
-<p>An email has been sent to you. You need to click link in it to activate your account.</p>
-{% endblocktrans %}
+    {% blocktrans %}
+        <h1>Thank you</h1>
+        <p>An email has been sent to you. You need to click link in it to
+            activate your account.</p>
+    {% endblocktrans %}
  
 {% endblock %}
@@ -3,36 +3,40 @@
 {% load url from future %}
  
 {% block extrahead %}
-  <style>
-    label {
-      vertical-align: top;
-      width: 100px;
-      display: inline-block;
-    }
-  </style>
+    <style>
+        label {
+            vertical-align: top;
+            width: 100px;
+            display: inline-block;
+        }
+    </style>
 {% endblock %}
  
 {% block title %}{% trans 'Registration' %}{% endblock %}
  
-{% block content %}<div id="content-main">
+{% block content %}
+    <div id="content-main">
  
-<form action="" method="post">{% csrf_token %}
-<div>
-{% if form.errors %}
-    <p class="errornote">
-    {% blocktrans count form.errors.items|length as counter %}Please correct the error below.{% plural %}Please correct the errors below.{% endblocktrans %}
-    </p>
-{% endif %}
+    <form action="" method="post">{% csrf_token %}
+        <div>
+            {% if form.errors %}
+                <p class="errornote">
+                    {% blocktrans count form.errors.items|length as counter %}
+                        Please correct the error below.{% plural %}Please
+                        correct the errors below.{% endblocktrans %}
+                </p>
+            {% endif %}
  
-<h1>{% trans 'Registration' %}</h1>
+            <h1>{% trans 'Registration' %}</h1>
  
-{{ form.as_p }}
+            {{ form.as_p }}
  
-<div class="submit-row">
-    <input type="submit" value="{% trans 'Add user' %}" class="default" />
-</div>
+            <div class="submit-row">
+                <input type="submit" value="{% trans 'Add user' %}"
+                       class="default"/>
+            </div>
  
-</div>
-</form></div>
+        </div>
+    </form></div>
  
 {% endblock %}
@@ -4,16 +4,16 @@
 {% block title %}Ustawienia{% endblock %}
  
 {% block content %}
-<h1>Ustawienia użytkownika</h1>
-<form method="post" action="">
-  {{ form.as_p }}
-  {% csrf_token %}
-  <input type="hidden" name="next" value="{{ next }}"/>
-  <button type="submit">
-    Zapisz
-  </button>
-</form>
-<p>
-  <a href="{% url 'auth_password_change' %}">Zmiana hasła</a>
-</p>
+    <h1>Ustawienia użytkownika</h1>
+    <form method="post" action="">
+        {{ form.as_p }}
+        {% csrf_token %}
+        <input type="hidden" name="next" value="{{ next }}"/>
+        <button type="submit">
+            Zapisz
+        </button>
+    </form>
+    <p>
+        <a href="{% url 'auth_password_change' %}">Zmiana hasła</a>
+    </p>
 {% endblock %}
@@ -6,13 +6,15 @@ from django.contrib.auth.models import User
  
  
 def set_history(user):
-  cursor = connection.cursor()
-  cursor.execute("SELECT set_config('var.user_id', %s, true)", [str(user.id)])
+    cursor = connection.cursor()
+    cursor.execute("SELECT set_config('var.user_id', %s, true)", [str(user.id)])
+
  
 def bot_history():
-  set_history(User.objects.get(username=u'Kuźniobot'))
+    set_history(User.objects.get(username=u'Kuźniobot'))
+
  
 def users_with_perm(perm):
-  return User.objects.filter(
-    Q(groups__permissions=perm) | Q(user_permissions=perm) |
-    Q(is_superuser=True)).distinct()
 \ No newline at end of file
+    return User.objects.filter(
+        Q(groups__permissions=perm) | Q(user_permissions=perm) |
+        Q(is_superuser=True)).distinct()
 \ No newline at end of file
@@ -9,43 +9,47 @@ from accounts.forms import AddUserForm, SettingsForm
 from accounts.models import UserSettings, manager_groups
 from dictionary.models import editable_vocabularies
  
+
 @permission_required('auth.add_user')
 @render('registration/registration_form.html')
 def register(request):
-  if request.method == 'POST':
-    form = AddUserForm(data=request.POST)
-    if form.is_valid():
-      form.save(request=request)
-      return HttpResponseRedirect(reverse('registration_complete'))
-  else:
-    form = AddUserForm()
-    if not request.user.has_perm('accounts.create_admin'):
-      choices = ((g.pk, g.name) for g in manager_groups())
-      form.fields['groups'].choices = choices
-  return {'form': form}
+    if request.method == 'POST':
+        form = AddUserForm(data=request.POST)
+        if form.is_valid():
+            form.save(request=request)
+            return HttpResponseRedirect(reverse('registration_complete'))
+    else:
+        form = AddUserForm()
+        if not request.user.has_perm('accounts.create_admin'):
+            choices = ((g.pk, g.name) for g in manager_groups())
+            form.fields['groups'].choices = choices
+    return {'form': form}
+
  
 @login_required
 @render()
 def settings(request):
-  user_settings, created = UserSettings.objects.get_or_create(user=request.user)
-  if request.method == 'POST':
-    form = SettingsForm(data=request.POST, instance=user_settings)
-    if form.is_valid():
-      form.save()
-      return HttpResponseRedirect(request.POST['next'])
-  else:
-    form = SettingsForm(
-      instance=user_settings,
-      vocabularies=editable_vocabularies(request.user))
-  return {'form': form, 'next': request.META.get('HTTP_REFERER', '')}
+    user_settings, created = UserSettings.objects.get_or_create(
+        user=request.user)
+    if request.method == 'POST':
+        form = SettingsForm(data=request.POST, instance=user_settings)
+        if form.is_valid():
+            form.save()
+            return HttpResponseRedirect(request.POST['next'])
+    else:
+        form = SettingsForm(
+            instance=user_settings,
+            vocabularies=editable_vocabularies(request.user))
+    return {'form': form, 'next': request.META.get('HTTP_REFERER', '')}
+
  
 @permission_required('auth.add_user')
 @render()
 def manage_groups(request):
-  users = User.objects.filter(is_superuser=False)
-  if request.user.has_perm('accounts.create_admin'):
-    groups = Group.objects.all()
-  else:
-    groups = manager_groups()
-  js_vars = {'ajax_set_group': reverse('set_group')}
-  return {'users': users, 'groups': groups, 'js_vars': js_vars}
+    users = User.objects.filter(is_superuser=False)
+    if request.user.has_perm('accounts.create_admin'):
+        groups = Group.objects.all()
+    else:
+        groups = manager_groups()
+    js_vars = {'ajax_set_group': reverse('set_group')}
+    return {'users': users, 'groups': groups, 'js_vars': js_vars}
 # -*- coding: utf-8 -*-
  
 def error_proc(request):
-  if request.session.get('error', ''):
-    error = request.session.pop('error')
-    return {'error': error}
-  else:
-    return {}
+    if request.session.get('error', ''):
+        error = request.session.pop('error')
+        return {'error': error}
+    else:
+        return {}
+
  
 def message_proc(request):
-  if request.session.get('message', ''):
-    message = request.session.pop('message')
-    return {'alert_message': message}
-  else:
-    return {}
+    if request.session.get('message', ''):
+        message = request.session.pop('message')
+        return {'alert_message': message}
+    else:
+        return {}
@@ -15,70 +15,84 @@ from common.util import stringify_keys
  
  
 class AjaxError(Exception):
-  pass
+    pass
+
  
 def json_decode_fallback(value):
-  try:
-    return json_decode(value)
-  except ValueError:
-    return value
+    try:
+        return json_decode(value)
+    except ValueError:
+        return value
+
  
 def ajax(login_required=True, method=None, encode_result=True, template=None):
-  def decorator(fun):
-    @wraps(fun)
-    def ajax_view(request):
-      kwargs = {}
-      request_params = None
-      if method == 'post':
-        request_params = request.POST
-      elif method == 'get':
-        request_params = request.GET
-      fun_params, xx, fun_kwargs, xxxx = getargspec(fun)
-      if request_params:
-        request_params = dict((key, json_decode_fallback(value))
-          for key, value in request_params.iteritems()
-          if fun_kwargs or key in fun_params)
-        kwargs.update(stringify_keys(request_params))
-      res = None
-      if login_required and not request.user.is_authenticated():
-        res = {'result': 'logout'}
-      if not res:
-        try:
-          res = fun(request, **kwargs)
-        except AjaxError as e:
-          transaction.rollback()
-          res = {'result': e.args[0]}
-      if template:
-        res = {'html': render_to_string(template, res, RequestContext(request))}
-      if encode_result:
-        if 'result' not in res:
-          res['result'] = 'ok'
-        return HttpResponse(json_encode(res), mimetype='application/json')
-      else:
-        return res
-    return ajax_view
-  return decorator
+    def decorator(fun):
+        @wraps(fun)
+        def ajax_view(request):
+            kwargs = {}
+            request_params = None
+            if method == 'post':
+                request_params = request.POST
+            elif method == 'get':
+                request_params = request.GET
+            fun_params, xx, fun_kwargs, xxxx = getargspec(fun)
+            if request_params:
+                request_params = dict((key, json_decode_fallback(value))
+                                      for key, value in
+                                      request_params.iteritems()
+                                      if fun_kwargs or key in fun_params)
+                kwargs.update(stringify_keys(request_params))
+            res = None
+            if login_required and not request.user.is_authenticated():
+                res = {'result': 'logout'}
+            if not res:
+                try:
+                    res = fun(request, **kwargs)
+                except AjaxError as e:
+                    transaction.rollback()
+                    res = {'result': e.args[0]}
+            if template:
+                res = {'html': render_to_string(template, res,
+                                                RequestContext(request))}
+            if encode_result:
+                if 'result' not in res:
+                    res['result'] = 'ok'
+                return HttpResponse(json_encode(res),
+                                    mimetype='application/json')
+            else:
+                return res
+
+        return ajax_view
+
+    return decorator
+
  
 def render(template=None, mimetype=None):
-  mimetype = mimetype or settings.DEFAULT_CONTENT_TYPE
-  template1 = template
-  def decorator(func):
-    template = template1 # no cóż...
-    if not template:
-      template = func.__name__ + '.html'
-    @wraps(func)
-    def renderer(request, *args, **kw):
-      output = func(request, *args, **kw)
-      if isinstance(output, (list, tuple)):
-        return render_to_response(
-          output[1], output[0], RequestContext(request), mimetype=mimetype)
-      elif isinstance(output, dict):
-        return render_to_response(
-          template, output, RequestContext(request), mimetype=mimetype)
-      return output
-    return renderer
-  return decorator
+    mimetype = mimetype or settings.DEFAULT_CONTENT_TYPE
+    template1 = template
+
+    def decorator(func):
+        template = template1 # no cóż...
+        if not template:
+            template = func.__name__ + '.html'
+
+        @wraps(func)
+        def renderer(request, *args, **kw):
+            output = func(request, *args, **kw)
+            if isinstance(output, (list, tuple)):
+                return render_to_response(
+                    output[1], output[0], RequestContext(request),
+                    mimetype=mimetype)
+            elif isinstance(output, dict):
+                return render_to_response(
+                    template, output, RequestContext(request),
+                    mimetype=mimetype)
+            return output
+
+        return renderer
+
+    return decorator
  
 # żeby były linki do szablonów w PyCharm przy ajaxach
 def render_template(t):
-  return lambda x: x
 \ No newline at end of file
+    return lambda x: x
 \ No newline at end of file
@@ -3,12 +3,14 @@
 from django import forms
 from django.utils.encoding import force_unicode
  
+
 def hidden_id(id):
-  return forms.CharField(initial=id, widget=forms.HiddenInput())
+    return forms.CharField(initial=id, widget=forms.HiddenInput())
  
 # http://www.djangosnippets.org/snippets/863/ z moimi zmianami
 class ChoiceWithOtherRenderer(forms.RadioSelect.renderer):
     """RadioFieldRenderer that renders its last choice with a placeholder."""
+
     def __init__(self, *args, **kwargs):
         super(ChoiceWithOtherRenderer, self).__init__(*args, **kwargs)
         self.choices, self.other = self.choices[:-1], self.choices[-1]
@@ -16,17 +18,22 @@ class ChoiceWithOtherRenderer(forms.RadioSelect.renderer):
     def __iter__(self):
         for input in super(ChoiceWithOtherRenderer, self).__iter__():
             yield input
-        id = '%s_%s' % (self.attrs['id'], self.other[0]) if 'id' in self.attrs else ''
+        id = '%s_%s' % (
+        self.attrs['id'], self.other[0]) if 'id' in self.attrs else ''
         label_for = ' for="%s"' % id if id else ''
-        checked = '' if not force_unicode(self.other[0]) == self.value else 'checked="true" '
+        checked = '' if not force_unicode(
+            self.other[0]) == self.value else 'checked="true" '
         yield '<label%s><input type="radio" id="%s" value="%s" name="%s" %s/> %s</label> %%s' % (
             label_for, id, self.other[0], self.name, checked, self.other[1])
  
+
 class ChoiceWithOtherWidget(forms.MultiWidget):
     """MultiWidget for use with ChoiceWithOtherField."""
+
     def __init__(self, choices):
         widgets = [
-            forms.RadioSelect(choices=choices, renderer=ChoiceWithOtherRenderer),
+            forms.RadioSelect(choices=choices,
+                              renderer=ChoiceWithOtherRenderer),
             forms.TextInput
         ]
         super(ChoiceWithOtherWidget, self).__init__(widgets)
@@ -40,20 +47,25 @@ class ChoiceWithOtherWidget(forms.MultiWidget):
         """Format the output by substituting the "other" choice into the first widget."""
         return rendered_widgets[0] % rendered_widgets[1]
  
+
 class ChoiceWithOtherField(forms.MultiValueField):
     """
     ChoiceField with an option for a user-submitted "other" value.
     """
+
     def __init__(self, *args, **kwargs):
         fields = [
-            forms.ChoiceField(widget=forms.RadioSelect(renderer=ChoiceWithOtherRenderer), *args, **kwargs),
+            forms.ChoiceField(
+                widget=forms.RadioSelect(renderer=ChoiceWithOtherRenderer),
+                *args, **kwargs),
             forms.CharField(required=False)
         ]
         widget = ChoiceWithOtherWidget(choices=kwargs['choices'])
         kwargs.pop('choices')
         self._was_required = kwargs.pop('required', True)
         kwargs['required'] = False
-        super(ChoiceWithOtherField, self).__init__(widget=widget, fields=fields, *args, **kwargs)
+        super(ChoiceWithOtherField, self).__init__(widget=widget, fields=fields,
+                                                   *args, **kwargs)
  
     def compress(self, value):
         if self._was_required and (not value or value[0] in (None, '')):
@@ -61,5 +73,6 @@ class ChoiceWithOtherField(forms.MultiValueField):
         if not value:
             return [None, u'']
         return (value[0], value[1]
-          if force_unicode(value[0]) == force_unicode(self.fields[0].choices[-1][0])
-          else self.fields[0].choices[int(value[0]) - 1][1])
 \ No newline at end of file
+        if force_unicode(value[0]) == force_unicode(
+            self.fields[0].choices[-1][0])
+        else self.fields[0].choices[int(value[0]) - 1][1])
 \ No newline at end of file
 #-*- coding:utf-8 -*-
  
-from django.db import connection
 from decimal import Decimal
  
+from django.db import connection
+
 from accounts.util import set_history
  
+
 class MyMiddleware(object):
-  def process_request(self, request):
-    if request.user.is_authenticated():
-      set_history(request.user)
+    def process_request(self, request):
+        if request.user.is_authenticated():
+            set_history(request.user)
  
-  def process_response(self, request, response):
-    if False:
-      if len(connection.queries) > 0:
-        print 'Queries for %s:' % request.path_info
-        for query in connection.queries:
-          print query['time'], query['sql']
-        print 'Total of %s queries for %s.' % (
-          len(connection.queries), request.path)
-        print 'Total time: %s' % sum(Decimal(q['time'])
-                                     for q in connection.queries)
-    return response
 \ No newline at end of file
+    def process_response(self, request, response):
+        if False:
+            if len(connection.queries) > 0:
+                print 'Queries for %s:' % request.path_info
+                for query in connection.queries:
+                    print query['time'], query['sql']
+                print 'Total of %s queries for %s.' % (
+                    len(connection.queries), request.path)
+                print 'Total time: %s' % sum(Decimal(q['time'])
+                                             for q in connection.queries)
+        return response
 \ No newline at end of file
-<p id="erroralert" style="display:{{ error|yesno:",none"}}">
-{{ error }}
+<p id="erroralert" style="display:{{ error|yesno:",none" }}">
+    {{ error }}
 </p>
-<p id="messagealert" style="display:{{ alert_message|yesno:",none"}}">
-{{ alert_message }}
+<p id="messagealert" style="display:{{ alert_message|yesno:",none" }}">
+    {{ alert_message }}
 </p>
 {% for menu_item in menu %}
-  <li>
-    <a href="{{ menu_item.url }}">
-      {{ menu_item.name }}
-    </a>
-  </li>
+    <li>
+        <a href="{{ menu_item.url }}">
+            {{ menu_item.name }}
+        </a>
+    </li>
 {% endfor %}
 \ No newline at end of file
@@ -4,10 +4,12 @@ from django.template import Library
  
 register = Library()
  
+
 @register.filter
 def format_date(date):
-  return date.strftime('%d.%m.%Y %H:%M')
+    return date.strftime('%d.%m.%Y %H:%M')
+
  
 @register.filter
 def format_date_exact(date):
-  return date.strftime('%d.%m.%Y %H:%M:%S.%f')
+    return date.strftime('%d.%m.%Y %H:%M:%S.%f')
@@ -4,6 +4,7 @@ from django.template import Library
  
 register = Library()
  
+
 @register.filter
 def get(dict, arg):
-  return dict[arg]
 \ No newline at end of file
+    return dict[arg]
 \ No newline at end of file
@@ -4,6 +4,7 @@ from django.template import Library
  
 register = Library()
  
+
 @register.filter
 def ingroup(user, group):
-  return group in user.groups.all()
+    return group in user.groups.all()
@@ -9,6 +9,7 @@ from django.template import Library
  
 register = Library()
  
+
 @register.filter
 def jsonify(object):
     if isinstance(object, QuerySet):
@@ -3,10 +3,12 @@ from django import template
  
 register = template.Library()
  
+
 @register.simple_tag
 def script():
-  return '<script type="text/javascript"> /* <![CDATA[ */'
+    return '<script type="text/javascript"> /* <![CDATA[ */'
+
  
 @register.simple_tag
 def endscript():
-  return '/* ]]> */ </script>'
+    return '/* ]]> */ </script>'
@@ -7,96 +7,116 @@ from django.http import HttpResponseRedirect, Http404
  
  
 def debug(entry, text):
-  print>>sys.stderr, (u'%s: %s' % (entry, text)).encode('utf-8')
+    print>> sys.stderr, (u'%s: %s' % (entry, text)).encode('utf-8')
+
  
 def error_redirect(request, error, url='/'):
-  request.session['error'] = error
-  return HttpResponseRedirect(url)
+    request.session['error'] = error
+    return HttpResponseRedirect(url)
+
  
 def message_redirect(request, message, url='/'):
-  request.session['message'] = message
-  return HttpResponseRedirect(url)
+    request.session['message'] = message
+    return HttpResponseRedirect(url)
+
  
 def make_form(request, form_class, **kwargs):
-  if request.POST.get('det', '') == form_class.base_fields['det'].initial:
-    return form_class(data=request.POST, files=request.FILES, **kwargs)
-  else:
-    return form_class(**kwargs)
+    if request.POST.get('det', '') == form_class.base_fields['det'].initial:
+        return form_class(data=request.POST, files=request.FILES, **kwargs)
+    else:
+        return form_class(**kwargs)
+
  
 def invert(l):
-  return dict((e,nr) for (nr,e) in enumerate(l))
+    return dict((e, nr) for (nr, e) in enumerate(l))
+
  
 def generator_slice(generator, count):
-  res = []
-  try:
-    for i in range(count):
-      res.append(generator.next())
-  except StopIteration:
-    pass
-  return res
+    res = []
+    try:
+        for i in range(count):
+            res.append(generator.next())
+    except StopIteration:
+        pass
+    return res
+
  
 def url(regex, view, **kwargs):
-  if 'name' not in kwargs:
-    kwargs['name'] = view.rsplit('.', 1)[-1]
-  return urls.url(regex, view, **kwargs)
+    if 'name' not in kwargs:
+        kwargs['name'] = view.rsplit('.', 1)[-1]
+    return urls.url(regex, view, **kwargs)
+
  
 def stringify_keys(dictionary):
-  return dict((keyword.encode('ascii'), value)
-    for keyword, value in dictionary.iteritems())
+    return dict((keyword.encode('ascii'), value)
+                for keyword, value in dictionary.iteritems())
  
 # copypasta ze standardowego modułu bisect
 def bisect_left(a, x, lo=0, hi=None, cmp=None):
-  if cmp is None:
-    cmp = __builtins__.cmp
-  if lo < 0:
-    raise ValueError('lo must be non-negative')
-  if hi is None:
-    hi = len(a)
-  while lo < hi:
-    mid = (lo+hi)//2
-    if cmp(a[mid], x) < 0: lo = mid+1
-    else: hi = mid
-  return lo
+    if cmp is None:
+        cmp = __builtins__.cmp
+    if lo < 0:
+        raise ValueError('lo must be non-negative')
+    if hi is None:
+        hi = len(a)
+    while lo < hi:
+        mid = (lo + hi) // 2
+        if cmp(a[mid], x) < 0:
+            lo = mid + 1
+        else:
+            hi = mid
+    return lo
+
  
 def no_history():
-  from django.db import connection
-  cursor = connection.cursor()
-  cursor.execute("SELECT set_config('var.user_id', '0', false)")
+    from django.db import connection
+
+    cursor = connection.cursor()
+    cursor.execute("SELECT set_config('var.user_id', '0', false)")
+
  
 def reverse(seq):
-  return seq[::-1]
+    return seq[::-1]
+
  
 def flatten(seq):
-  return [item for subseq in seq for item in subseq]
+    return [item for subseq in seq for item in subseq]
+
  
 def suffix(string, length):
-  return string[-length:] if length > 0 else ''
+    return string[-length:] if length > 0 else ''
+
  
 def suffixes(s):
-  return [s[i:] for i in range(len(s)+1)]
+    return [s[i:] for i in range(len(s) + 1)]
+
  
 def cut_end(s, end):
-  assert s.endswith(end)
-  n = len(end)
-  if n == 0:
-    return s
-  else:
-    return s[:-n]
+    assert s.endswith(end)
+    n = len(end)
+    if n == 0:
+        return s
+    else:
+        return s[:-n]
+
  
 def error_messages(form):
-  return '\n'.join(
-    '%s: %s' % (form.fields[k].label, ' '.join(v)) if k != '__all__'
-    else ' '.join(v)
-    for k, v in form.errors.iteritems())
+    return '\n'.join(
+        '%s: %s' % (form.fields[k].label, ' '.join(v)) if k != '__all__'
+        else ' '.join(v)
+        for k, v in form.errors.iteritems())
+
  
 class GroupDict(dict):
-  def add(self, key, value):
-    if key not in self:
-      self[key] = []
-    self[key].append(value)
+    def add(self, key, value):
+        if key not in self:
+            self[key] = []
+        self[key].append(value)
+
  
 def json_encode(obj):
-  return json.dumps(obj, sort_keys=True)
+    return json.dumps(obj, sort_keys=True)
+
  
 def json_decode(obj):
-  return json.loads(obj)
 \ No newline at end of file
+    return json.loads(obj)
 \ No newline at end of file
@@ -4,42 +4,46 @@ from common.decorators import render, ajax, AjaxError
 from dictionary.forms import MagicQualifierForm
 from dictionary.models import SavedExportData
  
+
 @render()
 @ajax(method='get', encode_result=False)
 def magic_qualifier_row(request):
-  return {'form': MagicQualifierForm(prefix='magic_NUM')}
+    return {'form': MagicQualifierForm(prefix='magic_NUM')}
+
  
 @ajax(method='post')
 def save_export_data(request, name, serialized_data, force=False):
-  existing_data = SavedExportData.objects.filter(name=name)
-  if force or not existing_data:
-    if existing_data:
-      data = existing_data[0]
+    existing_data = SavedExportData.objects.filter(name=name)
+    if force or not existing_data:
+        if existing_data:
+            data = existing_data[0]
+        else:
+            data = SavedExportData()
+            data.name = name
+        data.serialized_data = serialized_data
+        try:
+            data.save()
+        except ValueError as e:
+            raise AjaxError(e.data)
     else:
-      data = SavedExportData()
-      data.name = name
-    data.serialized_data = serialized_data
-    try:
-      data.save()
-    except ValueError as e:
-      raise AjaxError(e.data)
-  else:
-    return {'exists': True}
-  return {}
+        return {'exists': True}
+    return {}
+
  
 @ajax(method='get')
 def get_export_data(request):
-  data_list = [{
-    'id': 'export%s' % data.pk,
-    'name': data.name,
-    'json': data.serialized_data,
-    }
-    for data in SavedExportData.objects.all()]
-  return {'data_list': data_list}
+    data_list = [{
+                     'id': 'export%s' % data.pk,
+                     'name': data.name,
+                     'json': data.serialized_data,
+                 }
+                 for data in SavedExportData.objects.all()]
+    return {'data_list': data_list}
+
  
 @ajax(method='post')
 def delete_export_data(request, data_id):
-  export_data_id = data_id[len('export'):]
-  data = SavedExportData.objects.get(pk=export_data_id)
-  data.delete()
-  return {}
+    export_data_id = data_id[len('export'):]
+    data = SavedExportData.objects.get(pk=export_data_id)
+    data.delete()
+    return {}
@@ -3,41 +3,44 @@
 from common.decorators import ajax, AjaxError
 from dictionary.models import SavedFilter
  
+
 @ajax(method='post')
 def save_filter(request, name, serialized_filter, super=False, force=False):
-  existing_filter = SavedFilter.objects.filter(user=request.user, name=name)
-  if force or not existing_filter:
-    if existing_filter:
-      filter = existing_filter[0]
+    existing_filter = SavedFilter.objects.filter(user=request.user, name=name)
+    if force or not existing_filter:
+        if existing_filter:
+            filter = existing_filter[0]
+        else:
+            filter = SavedFilter()
+            filter.name = name
+            filter.user = request.user
+        filter.serialized_filter = serialized_filter
+        filter.super = super
+        try:
+            filter.save()
+        except ValueError as e:
+            raise AjaxError(e.data)
     else:
-      filter = SavedFilter()
-      filter.name = name
-      filter.user = request.user
-    filter.serialized_filter = serialized_filter
-    filter.super = super
-    try:
-      filter.save()
-    except ValueError as e:
-      raise AjaxError(e.data)
-  else:
-    return {'exists': True}
-  return {}
+        return {'exists': True}
+    return {}
+
  
 @ajax(method='get')
 def get_filters(request):
-  filters = [{
-               'id': 'filter%s' % filter.pk,
-               'name': filter.name,
-               'json': filter.serialized_filter,
-             }
-             for filter in SavedFilter.objects.filter(user=request.user)]
-  return {'filters': filters}
+    filters = [{
+                   'id': 'filter%s' % filter.pk,
+                   'name': filter.name,
+                   'json': filter.serialized_filter,
+               }
+               for filter in SavedFilter.objects.filter(user=request.user)]
+    return {'filters': filters}
+
  
 @ajax(method='post')
 def delete_filter(request, id):
-  filter_id = id[len('filter'):]
-  filter = SavedFilter.objects.get(pk=filter_id)
-  if filter.user != request.user:
-    raise AjaxError('access denied')
-  filter.delete()
-  return {}
+    filter_id = id[len('filter'):]
+    filter = SavedFilter.objects.get(pk=filter_id)
+    if filter.user != request.user:
+        raise AjaxError('access denied')
+    filter.delete()
+    return {}
@@ -4,10 +4,11 @@ from common.decorators import ajax, render_template
 from dictionary.models import History
 from dictionary.history import lexeme_tables
  
+
 @render_template('history_table.html')
 @ajax(method='get', template='history_table.html')
 def history_table(request, lexeme_id):
-  history_items = History.objects.filter(
-    lexeme__pk=lexeme_id).order_by('-transaction_began')
-  transaction_tables = lexeme_tables(history_items)
-  return {'transaction_tables': transaction_tables}
+    history_items = History.objects.filter(
+        lexeme__pk=lexeme_id).order_by('-transaction_began')
+    transaction_tables = lexeme_tables(history_items)
+    return {'transaction_tables': transaction_tables}
@@ -4,267 +4,270 @@ import math
 from accounts.models import filtering_mode
 from common.decorators import render, ajax
  
+
 class JqGridQuery(object):
-  def __init__(self, filters, sort_rules, mask, user):
-    self.filters = filters
-    self.sort_rules = sort_rules
-    self.mask = mask
-    self.user = user
+    def __init__(self, filters, sort_rules, mask, user):
+        self.filters = filters
+        self.sort_rules = sort_rules
+        self.mask = mask
+        self.user = user
+
+    def filtering_mode(self):
+        return filtering_mode(self.user)
  
-  def filtering_mode(self):
-    return filtering_mode(self.user)
  
 class JqGridAjax(object):
-  model = None
-  search_field = None
-  field_translation = {}
+    model = None
+    search_field = None
+    field_translation = {}
  
-  @classmethod
-  def translate_field(cls, field):
-    if field in cls.field_translation:
-      return cls.field_translation[field]
-    else:
-      return field
+    @classmethod
+    def translate_field(cls, field):
+        if field in cls.field_translation:
+            return cls.field_translation[field]
+        else:
+            return field
  
-  @staticmethod
-  def sort_field_special_case(rule):
-    return rule['field']
+    @staticmethod
+    def sort_field_special_case(rule):
+        return rule['field']
  
-  @classmethod
-  def get_sort_field(cls, rule):
-    field = cls.sort_field_special_case(rule)
-    field = cls.translate_field(field)
-    if rule['order'] == 'desc':
-      field = '-' + field
-    return field
+    @classmethod
+    def get_sort_field(cls, rule):
+        field = cls.sort_field_special_case(rule)
+        field = cls.translate_field(field)
+        if rule['order'] == 'desc':
+            field = '-' + field
+        return field
  
-  @staticmethod
-  def sort_queryset_special_case(queryset, field):
-    return queryset
+    @staticmethod
+    def sort_queryset_special_case(queryset, field):
+        return queryset
  
-  @classmethod
-  def sort_queryset(cls, queryset, sort_rules):
-    order_list = []
-    for rule in sort_rules:
-      queryset = cls.sort_queryset_special_case(queryset, rule)
-      order_list.append(cls.get_sort_field(rule))
-    return queryset.extra(order_by=order_list)
+    @classmethod
+    def sort_queryset(cls, queryset, sort_rules):
+        order_list = []
+        for rule in sort_rules:
+            queryset = cls.sort_queryset_special_case(queryset, rule)
+            order_list.append(cls.get_sort_field(rule))
+        return queryset.extra(order_by=order_list)
  
-  lookup_translation = {
-    'eq': 'exact',
-    'ne': '-exact',
-    'bw': 'startswith',
-    'bn': '-startswith',
-    'ew': 'endswith',
-    'en': '-endswith',
-    'cn': 'contains',
-    'nc': '-contains',
-    're': 'regex',
-    'nr': '-regex',
-    #'se': 'surely',
-    #'sd': '-maybe',
-    #'me': 'maybe',
-    #'md': '-surely',
-    'le': 'lte',
-    'ge': 'gte',
-  }
+    lookup_translation = {
+        'eq': 'exact',
+        'ne': '-exact',
+        'bw': 'startswith',
+        'bn': '-startswith',
+        'ew': 'endswith',
+        'en': '-endswith',
+        'cn': 'contains',
+        'nc': '-contains',
+        're': 'regex',
+        'nr': '-regex',
+        #'se': 'surely',
+        #'sd': '-maybe',
+        #'me': 'maybe',
+        #'md': '-surely',
+        'le': 'lte',
+        'ge': 'gte',
+    }
  
-  @staticmethod
-  def filter_special_case(filter, lookup, negated, queryset):
-    return False, filter['field'], queryset
+    @staticmethod
+    def filter_special_case(filter, lookup, negated, queryset):
+        return False, filter['field'], queryset
  
-  @classmethod
-  def apply_filter(cls, queryset, filter):
-    lookup = cls.lookup_translation[filter['op']]
-    negated = (lookup[0] == '-')
-    lookup = lookup.lstrip('-')
-    data = filter['data']
-    special, field, queryset = cls.filter_special_case(
-      filter, lookup, negated, queryset)
-    if not special:
-      arg = {(field + '__' + lookup): data}
-      if negated:
-        queryset = queryset.exclude(**arg)
-      else:
-        queryset = queryset.filter(**arg).distinct()
-    return queryset
+    @classmethod
+    def apply_filter(cls, queryset, filter):
+        lookup = cls.lookup_translation[filter['op']]
+        negated = (lookup[0] == '-')
+        lookup = lookup.lstrip('-')
+        data = filter['data']
+        special, field, queryset = cls.filter_special_case(
+            filter, lookup, negated, queryset)
+        if not special:
+            arg = {(field + '__' + lookup): data}
+            if negated:
+                queryset = queryset.exclude(**arg)
+            else:
+                queryset = queryset.filter(**arg).distinct()
+        return queryset
  
-  @classmethod
-  def get_queryset(cls, query):
-    return cls.model.objects.all()
+    @classmethod
+    def get_queryset(cls, query):
+        return cls.model.objects.all()
  
-  @classmethod
-  def get_empty_queryset(cls):
-    return cls.model.objects.none()
+    @classmethod
+    def get_empty_queryset(cls):
+        return cls.model.objects.none()
  
-  @classmethod
-  def apply_filters(cls, query):
-    filters = query.filters
-    queryset = cls.get_queryset(query)
-    if filters:
-      if filters['groupOp'] == 'AND':
-        for filter in filters['rules']:
-          queryset = cls.apply_filter(queryset, filter)
-      elif filters['groupOp'] == 'OR':
-        new_queryset = cls.get_empty_queryset()
-        for filter in filters['rules']:
-          new_queryset |= cls.apply_filter(queryset, filter)
-        queryset = new_queryset
-    return queryset
+    @classmethod
+    def apply_filters(cls, query):
+        filters = query.filters
+        queryset = cls.get_queryset(query)
+        if filters:
+            if filters['groupOp'] == 'AND':
+                for filter in filters['rules']:
+                    queryset = cls.apply_filter(queryset, filter)
+            elif filters['groupOp'] == 'OR':
+                new_queryset = cls.get_empty_queryset()
+                for filter in filters['rules']:
+                    new_queryset |= cls.apply_filter(queryset, filter)
+                queryset = new_queryset
+        return queryset
  
-  @staticmethod
-  def apply_mask(queryset, mask, sort_rules):
-    pass # abstract
+    @staticmethod
+    def apply_mask(queryset, mask, sort_rules):
+        pass # abstract
  
-  @staticmethod
-  def filter_value_special_case(queryset, rule, from_value, upward):
-    return False, queryset
+    @staticmethod
+    def filter_value_special_case(queryset, rule, from_value, upward):
+        return False, queryset
  
-  # filtruje queryset według pola z reguły rule od wartości from,
-  # wartości dalsze w porządku jeśli upward, w przeciwnym razie bliższe
-  @classmethod
-  def filter_value(cls, queryset, rule, from_value, upward):
-    greater = (rule['order'] == 'asc') == upward
-    special, queryset = cls.filter_value_special_case(
-      queryset, rule, from_value, upward)
-    if special:
-      return queryset
-    if greater:
-      lookup = '__gte'
-    else:
-      lookup = '__lte'
-    field = cls.translate_field(rule['field'])
-    return queryset.filter(**{field + lookup: from_value})
+    # filtruje queryset według pola z reguły rule od wartości from,
+    # wartości dalsze w porządku jeśli upward, w przeciwnym razie bliższe
+    @classmethod
+    def filter_value(cls, queryset, rule, from_value, upward):
+        greater = (rule['order'] == 'asc') == upward
+        special, queryset = cls.filter_value_special_case(
+            queryset, rule, from_value, upward)
+        if special:
+            return queryset
+        if greater:
+            lookup = '__gte'
+        else:
+            lookup = '__lte'
+        field = cls.translate_field(rule['field'])
+        return queryset.filter(**{field + lookup: from_value})
  
-  # id instancji z search_field rownym mask badz takiej, ktora bylaby nastepna
-  # po instancji z search_field równym mask w danym sortowaniu.
-  # Jezeli nie ma 'wiekszej' instancji badz reguly sortowania nie uwzgledniaja
-  # search_field, metoda zwroci pierwsza instancje w danym sortowaniu
-  #
-  # beznadziejna nazwa metody...
-  @classmethod
-  def get_pk(cls, query):
-    whole_queryset = cls.apply_filters(query)
-    queryset = whole_queryset
-    matching = cls.apply_mask(queryset, query.mask, query.sort_rules)
-    if matching.count() > 0:
-      matching = cls.sort_queryset(matching, query.sort_rules)
-      return matching[0].pk
-    else:
-      #gdy nie ma pasującego
-      rule = query.sort_rules[0]
-      if rule['field'] == cls.search_field:
-        queryset = cls.filter_value(
-          queryset, rule, from_value=query.mask, upward=True)
-        if queryset.count() == 0:
-          queryset = whole_queryset
-      queryset = cls.sort_queryset(queryset, query.sort_rules)
-      return queryset[0].pk
+    # id instancji z search_field rownym mask badz takiej, ktora bylaby nastepna
+    # po instancji z search_field równym mask w danym sortowaniu.
+    # Jezeli nie ma 'wiekszej' instancji badz reguly sortowania nie uwzgledniaja
+    # search_field, metoda zwroci pierwsza instancje w danym sortowaniu
+    #
+    # beznadziejna nazwa metody...
+    @classmethod
+    def get_pk(cls, query):
+        whole_queryset = cls.apply_filters(query)
+        queryset = whole_queryset
+        matching = cls.apply_mask(queryset, query.mask, query.sort_rules)
+        if matching.count() > 0:
+            matching = cls.sort_queryset(matching, query.sort_rules)
+            return matching[0].pk
+        else:
+            #gdy nie ma pasującego
+            rule = query.sort_rules[0]
+            if rule['field'] == cls.search_field:
+                queryset = cls.filter_value(
+                    queryset, rule, from_value=query.mask, upward=True)
+                if queryset.count() == 0:
+                    queryset = whole_queryset
+            queryset = cls.sort_queryset(queryset, query.sort_rules)
+            return queryset[0].pk
  
-  @staticmethod
-  def get_field_special_case(field, instance):
-    return False, None
+    @staticmethod
+    def get_field_special_case(field, instance):
+        return False, None
  
-  @classmethod
-  def get_field(cls, field, instance):
-    special, value = cls.get_field_special_case(field, instance)
-    if not special:
-      value = getattr(instance, field)
-    return cls.translate_field(field), value
+    @classmethod
+    def get_field(cls, field, instance):
+        special, value = cls.get_field_special_case(field, instance)
+        if not special:
+            value = getattr(instance, field)
+        return cls.translate_field(field), value
  
-  # indeks wiersza w danym sortowaniu, w którym
-  # znajdzie się instancja o danym id
-  @classmethod
-  def row_index(cls, pk, query):
-    selected = cls.model.objects.get(pk=pk)
-    queryset = cls.apply_filters(query)
-    if query.filtering_mode():
-      queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
-    count = queryset.count()
-    if count == 0:
-      return 0, 0
-    preceding = None
-    assert len(query.sort_rules) > 0
-    for rule in query.sort_rules:
-      field = rule['field']
-      field, data = cls.get_field(field, selected)
-      preceding = cls.filter_value(
-        queryset, rule, from_value=data, upward=False)
-    return preceding.count(), count
+    # indeks wiersza w danym sortowaniu, w którym
+    # znajdzie się instancja o danym id
+    @classmethod
+    def row_index(cls, pk, query):
+        selected = cls.model.objects.get(pk=pk)
+        queryset = cls.apply_filters(query)
+        if query.filtering_mode():
+            queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
+        count = queryset.count()
+        if count == 0:
+            return 0, 0
+        preceding = None
+        assert len(query.sort_rules) > 0
+        for rule in query.sort_rules:
+            field = rule['field']
+            field, data = cls.get_field(field, selected)
+            preceding = cls.filter_value(
+                queryset, rule, from_value=data, upward=False)
+        return preceding.count(), count
  
-  # też beznadziejna nazwa
-  @classmethod
-  def find_id(cls, selected_pk, query):
-    index, count = cls.row_index(selected_pk, query)
-    return {
-      'rowIndex': index,
-      'records': count,
-    }
+    # też beznadziejna nazwa
+    @classmethod
+    def find_id(cls, selected_pk, query):
+        index, count = cls.row_index(selected_pk, query)
+        return {
+            'rowIndex': index,
+            'records': count,
+        }
  
-  @classmethod
-  def get_location(cls, query):
-    queryset = cls.apply_filters(query)
-    count = queryset.count()
-    # nie wiem, czy ma sens - wzorów i tak jest mało, a leksemy są keszowane
-    if count > 0 and query.mask == '':
-      return {
-        'rowIndex': 0,
-        'selected_id': queryset[0].pk,
-        'records': count,
-      }
-    if query.filtering_mode():
-      queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
-    if queryset.count() > 0:
-      selected_pk = cls.get_pk(query)
-      index, _count = cls.row_index(selected_pk, query)
-    else:
-      index = None
-      selected_pk = None
-    return {
-      'rowIndex': index,
-      'selected_id': selected_pk,
-      'records': count,
-    }
+    @classmethod
+    def get_location(cls, query):
+        queryset = cls.apply_filters(query)
+        count = queryset.count()
+        # nie wiem, czy ma sens - wzorów i tak jest mało, a leksemy są keszowane
+        if count > 0 and query.mask == '':
+            return {
+                'rowIndex': 0,
+                'selected_id': queryset[0].pk,
+                'records': count,
+            }
+        if query.filtering_mode():
+            queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
+        if queryset.count() > 0:
+            selected_pk = cls.get_pk(query)
+            index, _count = cls.row_index(selected_pk, query)
+        else:
+            index = None
+            selected_pk = None
+        return {
+            'rowIndex': index,
+            'selected_id': selected_pk,
+            'records': count,
+        }
  
-  @classmethod
-  def get_sorted_queryset(cls, query):
-    queryset = cls.apply_filters(query)
-    if query.filtering_mode():
-      queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
-    return cls.sort_queryset(queryset, query.sort_rules)
+    @classmethod
+    def get_sorted_queryset(cls, query):
+        queryset = cls.apply_filters(query)
+        if query.filtering_mode():
+            queryset = cls.apply_mask(queryset, query.mask, query.sort_rules)
+        return cls.sort_queryset(queryset, query.sort_rules)
  
-  @staticmethod
-  def count_pages(count, page, limit):
-    total_pages = int(math.ceil(float(count) / limit))
-    if limit < 0:
-      limit = 0
-    page = min(page, total_pages)
-    start = limit * (page - 1)
-    start = max(start, 0)
-    response_rowcount = min(limit, count - start)
-    return total_pages, start, response_rowcount
+    @staticmethod
+    def count_pages(count, page, limit):
+        total_pages = int(math.ceil(float(count) / limit))
+        if limit < 0:
+            limit = 0
+        page = min(page, total_pages)
+        start = limit * (page - 1)
+        start = max(start, 0)
+        response_rowcount = min(limit, count - start)
+        return total_pages, start, response_rowcount
  
-  @staticmethod
-  def response_row(instance):
-    pass # abstract
+    @staticmethod
+    def response_row(instance):
+        pass # abstract
  
-  @classmethod
-  def make_response(cls, response_qs, count, page, total_pages):
-    rows = [{
-              'id': instance.pk,
-              'cell': cls.response_row(instance),
-            } for instance in response_qs]
-    return {
-      'page': page,
-      'total': total_pages,
-      'records': count,
-      'rows': rows,
-    }
+    @classmethod
+    def make_response(cls, response_qs, count, page, total_pages):
+        rows = [{
+                    'id': instance.pk,
+                    'cell': cls.response_row(instance),
+                } for instance in response_qs]
+        return {
+            'page': page,
+            'total': total_pages,
+            'records': count,
+            'rows': rows,
+        }
  
-  @classmethod
-  def get_page(cls, page, limit, query):
-    queryset = cls.get_sorted_queryset(query)
-    count = queryset.count()
-    total_pages, start, response_rowcount = cls.count_pages(count, page, limit)
-    response_qs = queryset[start:start + response_rowcount]
-    return cls.make_response(response_qs, count, page, total_pages)
 \ No newline at end of file
+    @classmethod
+    def get_page(cls, page, limit, query):
+        queryset = cls.get_sorted_queryset(query)
+        count = queryset.count()
+        total_pages, start, response_rowcount = cls.count_pages(count, page,
+                                                                limit)
+        response_qs = queryset[start:start + response_rowcount]
+        return cls.make_response(response_qs, count, page, total_pages)
 \ No newline at end of file
@@ -2,60 +2,62 @@
 from hashlib import md5
  
 from django.db.models import Count
+from django.core.cache import cache
+
 from dictionary.models import Lexeme, filter_visible, visible_vocabularies, LexemeInflectionPattern, LexemeAssociation
 from dictionary.ajax_jqgrid import JqGridAjax, JqGridQuery
 from common.decorators import ajax
 from common.util import bisect_left, reverse, GroupDict, json_encode
-from django.core.cache import cache
-
-class LexemeGrid(JqGridAjax):
-  model = Lexeme
-  search_field = 'entry'
-  field_translation = {
-    'part_of_speech': 'part_of_speech__symbol',
-  }
-
-  @staticmethod
-  def sort_field_special_case(rule):
-    if rule['field'] == 'entry' and rule['a_tergo']:
-      return 'rev'
-    else:
-      return rule['field']
  
-  @staticmethod
-  def sort_queryset_special_case(queryset, rule):
-    if rule['field'] == 'entry' and rule['a_tergo']:
-      return queryset.extra(select={'rev': "reverse(haslo)"})
-    else:
-      return queryset
  
-  @staticmethod
-  def filter_special_case(filter, lookup, negated, queryset):
-    field, data = filter['field'], filter['data']
-    special = False
+class LexemeGrid(JqGridAjax):
+    model = Lexeme
+    search_field = 'entry'
     field_translation = {
-      'form': 'lexemeform__form',
-      'lexeme_qualifier': 'qualifiers__pk',
-      'lip_qualifier': 'lexemeinflectionpattern__qualifiers__pk',
-      'classification_value': 'classificationvalue__pk',
-      'pattern_name': 'lexemeinflectionpattern__pattern__name',
-      'inflection_characteristic':
-        'lexemeinflectionpattern__inflection_characteristic__symbol',
-      'containing_vocabulary': 'vocabularies__pk',
-      'owner_vocabulary': 'owner_vocabulary__pk',
-      'pattern_count': 'pc',
-      'ic_count': 'icc',
-      'cr_type': 'refs_to__type__pk',
+        'part_of_speech': 'part_of_speech__symbol',
     }
-    if field == 'pattern_count':
-      queryset = queryset.annotate(
-        pc=Count('lexemeinflectionpattern__pattern', distinct=True))
-    elif field == 'ic_count':
-      queryset = queryset.annotate(
-        icc=Count('lexemeinflectionpattern__inflection_characteristic',
-          distinct=True))
-    elif field == 'qualifier':
-      where = '''(
+
+    @staticmethod
+    def sort_field_special_case(rule):
+        if rule['field'] == 'entry' and rule['a_tergo']:
+            return 'rev'
+        else:
+            return rule['field']
+
+    @staticmethod
+    def sort_queryset_special_case(queryset, rule):
+        if rule['field'] == 'entry' and rule['a_tergo']:
+            return queryset.extra(select={'rev': "reverse(haslo)"})
+        else:
+            return queryset
+
+    @staticmethod
+    def filter_special_case(filter, lookup, negated, queryset):
+        field, data = filter['field'], filter['data']
+        special = False
+        field_translation = {
+            'form': 'lexemeform__form',
+            'lexeme_qualifier': 'qualifiers__pk',
+            'lip_qualifier': 'lexemeinflectionpattern__qualifiers__pk',
+            'classification_value': 'classificationvalue__pk',
+            'pattern_name': 'lexemeinflectionpattern__pattern__name',
+            'inflection_characteristic':
+                'lexemeinflectionpattern__inflection_characteristic__symbol',
+            'containing_vocabulary': 'vocabularies__pk',
+            'owner_vocabulary': 'owner_vocabulary__pk',
+            'pattern_count': 'pc',
+            'ic_count': 'icc',
+            'cr_type': 'refs_to__type__pk',
+        }
+        if field == 'pattern_count':
+            queryset = queryset.annotate(
+                pc=Count('lexemeinflectionpattern__pattern', distinct=True))
+        elif field == 'ic_count':
+            queryset = queryset.annotate(
+                icc=Count('lexemeinflectionpattern__inflection_characteristic',
+                          distinct=True))
+        elif field == 'qualifier':
+            where = '''(
         exists (
           select * from kwalifikatory_leksemow where lexeme_id = leksemy.id and
             qualifier_id = %s) or
@@ -75,200 +77,209 @@ class LexemeGrid(JqGridAjax):
           where o.l_id = leksemy.id and s.wariant = '1' and
             kz.qualifier_id = %s)
       )'''
-      if negated:
-        where = 'not ' + where
-      queryset = queryset.extra(where=[where], params=[data] * 3)
-      special = True
-    return special, field_translation.get(field, field), queryset
-
-  @classmethod
-  def get_queryset(cls, query):
-    lexemes = super(LexemeGrid, cls).get_queryset(query)
-    return filter_visible(lexemes, query.user)
-
-  @staticmethod
-  def apply_mask(lexemes, mask, sort_rules):
-    if mask == '':
-      return lexemes
-    for rule in sort_rules:
-      if rule['field'] == 'entry':
-        if not rule['a_tergo']:
-          matching_lexemes = lexemes.filter(entry__istartswith=mask)
+            if negated:
+                where = 'not ' + where
+            queryset = queryset.extra(where=[where], params=[data] * 3)
+            special = True
+        return special, field_translation.get(field, field), queryset
+
+    @classmethod
+    def get_queryset(cls, query):
+        lexemes = super(LexemeGrid, cls).get_queryset(query)
+        return filter_visible(lexemes, query.user)
+
+    @staticmethod
+    def apply_mask(lexemes, mask, sort_rules):
+        if mask == '':
+            return lexemes
+        for rule in sort_rules:
+            if rule['field'] == 'entry':
+                if not rule['a_tergo']:
+                    matching_lexemes = lexemes.filter(entry__istartswith=mask)
+                else:
+                    matching_lexemes = lexemes.filter(entry__iendswith=mask)
+                break
         else:
-          matching_lexemes = lexemes.filter(entry__iendswith=mask)
-        break
-    else:
-      matching_lexemes = lexemes.filter(entry__istartswith=mask)
-    return matching_lexemes
-
-  @staticmethod
-  def filter_value_special_case(queryset, rule, from_value, greater):
-    if rule['field'] == 'entry' and rule['a_tergo']:
-      if greater:
-        comp = '>='
-      else:
-        comp = '<='
-      queryset = queryset.extra(where=["reverse(haslo) " + comp + " %s"],
-                                params=[reverse(from_value)])
-      return True, queryset
-    else:
-      return False, queryset
+            matching_lexemes = lexemes.filter(entry__istartswith=mask)
+        return matching_lexemes
+
+    @staticmethod
+    def filter_value_special_case(queryset, rule, from_value, greater):
+        if rule['field'] == 'entry' and rule['a_tergo']:
+            if greater:
+                comp = '>='
+            else:
+                comp = '<='
+            queryset = queryset.extra(where=["reverse(haslo) " + comp + " %s"],
+                                      params=[reverse(from_value)])
+            return True, queryset
+        else:
+            return False, queryset
+
+    @staticmethod
+    def get_field_special_case(field, lexeme):
+        if field == 'part_of_speech':
+            return True, lexeme.part_of_speech.symbol
+        else:
+            return False, None
+
+    @staticmethod
+    def response_row(lexeme):
+        lip_data = lexeme.lip_data()
+        cont_vocabs = '/'.join(v.id for v in lexeme.vocabularies.all())
+        return [
+            lexeme.id,
+            lexeme.entry,
+            lexeme.part_of_speech.symbol,
+            lip_data['patterns'],
+            '', # brak liczby wzorów
+            lip_data['inflection_characteristics'],
+            '', # brak liczby charfli
+            '', # brak formy
+            cont_vocabs,
+            lexeme.owner_vocabulary.id,
+            dict(Lexeme.STATUS_CHOICES).get(lexeme.status),
+            '', # brak komentarza
+        ]
+
+    # indeks wiersza w danym sortowaniu, w którym
+    # znajdzie się instancja o danym id
+    @classmethod
+    def row_index(cls, pk, query):
+        pk_list = get_pk_list(query)
+        count = len(pk_list)
+        if count == 0:
+            return 0, 0
+        return pk_list.index(pk), count
+
+    # id instancji z search_field rownym mask badz takiej, ktora bylaby nastepna
+    # po instancji z search_field równym mask w danym sortowaniu.
+    # Jezeli nie ma 'wiekszej' instancji badz reguly sortowania nie uwzgledniaja
+    # search_field, metoda zwroci pierwsza instancje w danym sortowaniu
+    @classmethod
+    def get_pk(cls, query):
+        pk_list = get_pk_list(query)
+        count = len(pk_list)
+        if count == 0:
+            return None, None, 0
+            # nie podoba mi się w ogóle cała ta idea
+        sort_rules = query.sort_rules
+        assert len(sort_rules) >= 0
+        if sort_rules[0]['field'] != cls.search_field:
+            selected_pk = super(cls, LexemeGrid).get_pk(query)
+            index, count = cls.row_index(selected_pk, query)
+            return selected_pk, index, count
+
+        index = bisect_left(pk_list, query.mask,
+                            cmp=make_lexeme_cmp(sort_rules[0]))
+        if index == count:
+            index -= 1
+        return pk_list[index], index, count
+
+    @classmethod
+    def get_location(cls, query):
+        selected_pk, index, count = cls.get_pk(query)
+        return {
+            'rowIndex': index,
+            'selected_id': selected_pk,
+            'records': count,
+        }
  
-  @staticmethod
-  def get_field_special_case(field, lexeme):
-    if field == 'part_of_speech':
-      return True, lexeme.part_of_speech.symbol
-    else:
-      return False, None
-
-  @staticmethod
-  def response_row(lexeme):
-    lip_data = lexeme.lip_data()
-    cont_vocabs = '/'.join(v.id for v in lexeme.vocabularies.all())
-    return [
-      lexeme.id,
-      lexeme.entry,
-      lexeme.part_of_speech.symbol,
-      lip_data['patterns'],
-      '', # brak liczby wzorów
-      lip_data['inflection_characteristics'],
-      '', # brak liczby charfli
-      '', # brak formy
-      cont_vocabs,
-      lexeme.owner_vocabulary.id,
-      dict(Lexeme.STATUS_CHOICES).get(lexeme.status),
-      '', # brak komentarza
-    ]
-
-  # indeks wiersza w danym sortowaniu, w którym
-  # znajdzie się instancja o danym id
-  @classmethod
-  def row_index(cls, pk, query):
-    pk_list = get_pk_list(query)
-    count = len(pk_list)
-    if count == 0:
-      return 0, 0
-    return pk_list.index(pk), count
-
-  # id instancji z search_field rownym mask badz takiej, ktora bylaby nastepna
-  # po instancji z search_field równym mask w danym sortowaniu.
-  # Jezeli nie ma 'wiekszej' instancji badz reguly sortowania nie uwzgledniaja
-  # search_field, metoda zwroci pierwsza instancje w danym sortowaniu
-  @classmethod
-  def get_pk(cls, query):
-    pk_list = get_pk_list(query)
-    count = len(pk_list)
-    if count == 0:
-      return None, None, 0
-    # nie podoba mi się w ogóle cała ta idea
-    sort_rules = query.sort_rules
-    assert len(sort_rules) >= 0
-    if sort_rules[0]['field'] != cls.search_field:
-      selected_pk = super(cls, LexemeGrid).get_pk(query)
-      index, count = cls.row_index(selected_pk, query)
-      return selected_pk, index, count
-
-    index = bisect_left(pk_list, query.mask, cmp=make_lexeme_cmp(sort_rules[0]))
-    if index == count:
-      index -= 1
-    return pk_list[index], index, count
-
-  @classmethod
-  def get_location(cls, query):
-    selected_pk, index, count = cls.get_pk(query)
-    return {
-      'rowIndex': index,
-      'selected_id': selected_pk,
-      'records': count,
-    }
  
 import locale
+
 locale.setlocale(locale.LC_ALL, 'pl_PL.UTF-8')
  
+
 def make_lexeme_cmp(rule):
-  def lexeme_cmp(pk, mask):
-    e1 = Lexeme.objects.get(pk=pk).entry
-    e2 = mask
-    if rule['a_tergo']:
-      e1 = reverse(e1)
-      e2 = reverse(e2)
-    result = locale.strcoll(e1, e2)
-    if rule['order'] == 'desc' and e2 != '':
-      result = -result
-    return result
-  return lexeme_cmp
+    def lexeme_cmp(pk, mask):
+        e1 = Lexeme.objects.get(pk=pk).entry
+        e2 = mask
+        if rule['a_tergo']:
+            e1 = reverse(e1)
+            e2 = reverse(e2)
+        result = locale.strcoll(e1, e2)
+        if rule['order'] == 'desc' and e2 != '':
+            result = -result
+        return result
+
+    return lexeme_cmp
  
 # Zapytanie o indeks wiersza o pewnym id przy danym sortowaniu
 @ajax(method='get')
 def find_id(request, id, sort_rules, mask, filters=None):
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  return LexemeGrid.find_id(id, query)
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    return LexemeGrid.find_id(id, query)
  
 # Zapytanie o id oraz indeks pierwszego wiersza przy danym sortowaniu,
 # którego hasło rozpoczyna się od mask.
 # 'selected_id' == None, jeśli takiego nie ma
 @ajax(method='get')
 def get_location(request, sort_rules, mask='', filters=None):
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  return LexemeGrid.get_location(query)
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    return LexemeGrid.get_location(query)
  
 # twór Miłosza - trzeba kiedyś poprawić
 def cache_key(query):
-  key = json_encode(query.sort_rules) + json_encode(query.filters)
-  for vocabulary in visible_vocabularies(query.user):
-    key += vocabulary.id
-  if query.filtering_mode():
-    key += query.mask
-  return md5(key).hexdigest()
+    key = json_encode(query.sort_rules) + json_encode(query.filters)
+    for vocabulary in visible_vocabularies(query.user):
+        key += vocabulary.id
+    if query.filtering_mode():
+        key += query.mask
+    return md5(key).hexdigest()
+
  
 def get_cached_lexemes(query):
-  key = cache_key(query)
-  return cache.get(key)
+    key = cache_key(query)
+    return cache.get(key)
+
  
 def cache_lexemes(pk_list, query):
-  key = cache_key(query)
-  cache.set(key, pk_list)
-  key_list = cache.get('key_list', [])
-  if key not in key_list:
-    key_list.append(key)
-  cache.set('key_list', key_list)
+    key = cache_key(query)
+    cache.set(key, pk_list)
+    key_list = cache.get('key_list', [])
+    if key not in key_list:
+        key_list.append(key)
+    cache.set('key_list', key_list)
+
  
 def get_pk_list(query, force_reload=False):
-  if not force_reload:
-    pk_list = get_cached_lexemes(query)
-  else:
-    pk_list = None
-  if pk_list is None:
-    lexemes = LexemeGrid.get_sorted_queryset(query)
-    if 'rev' in lexemes.query.extra_select:
-      pk_list = list(row[0] for row in lexemes.values_list('pk', 'rev'))
+    if not force_reload:
+        pk_list = get_cached_lexemes(query)
     else:
-      #print lexemes.values_list('pk', flat=True).query
-      pk_list = list(lexemes.values_list('pk', flat=True))
-    cache_lexemes(pk_list, query)
-  return pk_list
+        pk_list = None
+    if pk_list is None:
+        lexemes = LexemeGrid.get_sorted_queryset(query)
+        if 'rev' in lexemes.query.extra_select:
+            pk_list = list(row[0] for row in lexemes.values_list('pk', 'rev'))
+        else:
+            #print lexemes.values_list('pk', flat=True).query
+            pk_list = list(lexemes.values_list('pk', flat=True))
+        cache_lexemes(pk_list, query)
+    return pk_list
+
  
 @ajax(method='get')
 def get_lexemes(request, page, rows, sort_rules, filters=None, mask='',
                 target_page=0, totalrows=0, force_reload=False):
-  request.session['sort_rules'] = json_encode(sort_rules)
-  request.session['filters'] = json_encode(filters)
-  page = target_page or page
-  limit = totalrows or rows
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  pk_list = get_pk_list(query, force_reload)
-  count = len(pk_list)
-  total_pages, start, response_rowcount = LexemeGrid.count_pages(
-    count, page, limit)
-  sublist = pk_list[start:start + response_rowcount]
-  lexemes_qs = Lexeme.objects.filter(pk__in=sublist).select_related(
-    'owner_vocabulary', 'part_of_speech').prefetch_related(
-    'lexemeinflectionpattern_set__pattern',
-    'lexemeinflectionpattern_set__inflection_characteristic',
-    'vocabularies')
-  lexemes_dict = dict((l.pk, l) for l in lexemes_qs)
-  lexemes = [lexemes_dict[pk] for pk in sublist]
-  return LexemeGrid.make_response(lexemes, count, page, total_pages)
+    request.session['sort_rules'] = json_encode(sort_rules)
+    request.session['filters'] = json_encode(filters)
+    page = target_page or page
+    limit = totalrows or rows
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    pk_list = get_pk_list(query, force_reload)
+    count = len(pk_list)
+    total_pages, start, response_rowcount = LexemeGrid.count_pages(
+        count, page, limit)
+    sublist = pk_list[start:start + response_rowcount]
+    lexemes_qs = Lexeme.objects.filter(pk__in=sublist).select_related(
+        'owner_vocabulary', 'part_of_speech').prefetch_related(
+        'lexemeinflectionpattern_set__pattern',
+        'lexemeinflectionpattern_set__inflection_characteristic',
+        'vocabularies')
+    lexemes_dict = dict((l.pk, l) for l in lexemes_qs)
+    lexemes = [lexemes_dict[pk] for pk in sublist]
+    return LexemeGrid.make_response(lexemes, count, page, total_pages)
@@ -7,552 +7,584 @@ from django.db.models import Max
 from dictionary.ajax_jqgrid import JqGridQuery
 from dictionary.ajax_lexeme_jqgrid import cache_key, get_pk_list
 from dictionary.models import Lexeme, LexemeInflectionPattern, PartOfSpeech, \
-  Pattern, InflectionCharacteristic, Vocabulary, Qualifier, \
-  prepare_table, ClassificationValue, CrossReference, TableTemplate, get_root, \
-  InputLexeme, CrossReferenceType, filter_visible, \
-  editable_vocabularies, visible_qualifiers, LexemeAttributeValue
+    Pattern, InflectionCharacteristic, Vocabulary, Qualifier, \
+    prepare_table, ClassificationValue, CrossReference, TableTemplate, get_root, \
+    InputLexeme, CrossReferenceType, filter_visible, \
+    editable_vocabularies, visible_qualifiers, LexemeAttributeValue
 from dictionary.forms import LexemeEditForm, LIPEditForm, ClassificationForm, \
-  CrossReferenceForm, ActionFieldForm, ACTION_FIELDS, LexemeOpenAttributeForm, \
-  LexemeClosedAttributeForm, LexemeMultipleAttributeForm
+    CrossReferenceForm, ActionFieldForm, ACTION_FIELDS, LexemeOpenAttributeForm, \
+    LexemeClosedAttributeForm, LexemeMultipleAttributeForm
 from common.decorators import render, ajax, AjaxError, render_template
 from common.util import error_messages
  
+
 @ajax(method='get', template='inflection_tables.html')
 def get_inflection_tables(request, variant, lexeme_id):
-  lexeme = Lexeme.all_objects.get(pk=lexeme_id) # może być nowy
-  if not lexeme.perm(request.user, 'view'):
-    raise AjaxError('access denied')
-  qualifiers = visible_qualifiers(request.user)
-  tables = lexeme.inflection_tables(variant, qualifiers=qualifiers)
-  return {
-    'tables': tables,
-    'lexeme': lexeme,
-    'cross_references': lexeme.refs_to.order_by('type__index'),
-    'info': lexeme.sgjp_info(),
-  }
+    lexeme = Lexeme.all_objects.get(pk=lexeme_id) # może być nowy
+    if not lexeme.perm(request.user, 'view'):
+        raise AjaxError('access denied')
+    qualifiers = visible_qualifiers(request.user)
+    tables = lexeme.inflection_tables(variant, qualifiers=qualifiers)
+    return {
+        'tables': tables,
+        'lexeme': lexeme,
+        'cross_references': lexeme.refs_to.order_by('type__index'),
+        'info': lexeme.sgjp_info(),
+    }
+
  
 @ajax(method='get', template='inflection_table.html')
 def table_preview(request, lexeme_id, pattern, inflection_characteristic,
                   lip_id, entry=None, pos=None):
-  lexeme = Lexeme.all_objects.get(pk=lexeme_id)
-  if not lexeme.perm(request.user, 'view'):
-    raise AjaxError('access denied')
-  if entry is None:
-    entry = lexeme.entry
-  if pos is None:
-    pos = lexeme.part_of_speech.symbol
-  try:
-    pattern = Pattern.objects.get(name=pattern)
-    inflection_characteristic = InflectionCharacteristic.objects.get(
-      pk=inflection_characteristic)
-    if lip_id.startswith('lip_add'):
-      lip = LexemeInflectionPattern(lexeme=lexeme, index=0)
-    else:
-      lip = LexemeInflectionPattern.objects.get(pk=int(lip_id[3:]))
-    lip.pattern = pattern
-    lip.inflection_characteristic = inflection_characteristic
-    lip.root = get_root(entry, pos, pattern, inflection_characteristic)
-    qualifiers = visible_qualifiers(request.user)
-    table = lip.inflection_table('0', separated=True, qualifiers=qualifiers,
-                                 edit_view=True)
-    prepare_table(table)
-  except Pattern.DoesNotExist:
-    table = None
-  except TableTemplate.DoesNotExist:
-    table = None
-  return {'table': table}
+    lexeme = Lexeme.all_objects.get(pk=lexeme_id)
+    if not lexeme.perm(request.user, 'view'):
+        raise AjaxError('access denied')
+    if entry is None:
+        entry = lexeme.entry
+    if pos is None:
+        pos = lexeme.part_of_speech.symbol
+    try:
+        pattern = Pattern.objects.get(name=pattern)
+        inflection_characteristic = InflectionCharacteristic.objects.get(
+            pk=inflection_characteristic)
+        if lip_id.startswith('lip_add'):
+            lip = LexemeInflectionPattern(lexeme=lexeme, index=0)
+        else:
+            lip = LexemeInflectionPattern.objects.get(pk=int(lip_id[3:]))
+        lip.pattern = pattern
+        lip.inflection_characteristic = inflection_characteristic
+        lip.root = get_root(entry, pos, pattern, inflection_characteristic)
+        qualifiers = visible_qualifiers(request.user)
+        table = lip.inflection_table('0', separated=True, qualifiers=qualifiers,
+                                     edit_view=True)
+        prepare_table(table)
+    except Pattern.DoesNotExist:
+        table = None
+    except TableTemplate.DoesNotExist:
+        table = None
+    return {'table': table}
+
  
 @ajax(method='get', template="odm_forms.html")
 def odm_forms(request, lexeme_id):
-  to_return = {}
-  l = Lexeme.all_objects.get(pk=lexeme_id)
-  if not l.perm(request.user, 'view'):
-    raise AjaxError('access denied')
-  odm_lexemes = []
-  for l in InputLexeme.objects.filter(entry=l.entry):
-    odm_lexemes.append(list(l.inputform_set.values_list('form', flat=True)))
-  to_return['odm_lexemes'] = odm_lexemes
-  return to_return
+    to_return = {}
+    l = Lexeme.all_objects.get(pk=lexeme_id)
+    if not l.perm(request.user, 'view'):
+        raise AjaxError('access denied')
+    odm_lexemes = []
+    for l in InputLexeme.objects.filter(entry=l.entry):
+        odm_lexemes.append(list(l.inputform_set.values_list('form', flat=True)))
+    to_return['odm_lexemes'] = odm_lexemes
+    return to_return
+
  
 def attribute_forms(l, part_of_speech=None, ics=None):
-  for attr, v in l.attributes_values(part_of_speech, ics):
-    if not attr.closed:
-      form_class = LexemeOpenAttributeForm
-    elif not attr.multiple:
-      form_class = LexemeClosedAttributeForm
-    else:
-      form_class = LexemeMultipleAttributeForm
-    prefix = 'attr%s' % attr.pk
-    yield form_class(attribute=attr, initial_value=v, prefix=prefix)
+    for attr, v in l.attributes_values(part_of_speech, ics):
+        if not attr.closed:
+            form_class = LexemeOpenAttributeForm
+        elif not attr.multiple:
+            form_class = LexemeClosedAttributeForm
+        else:
+            form_class = LexemeMultipleAttributeForm
+        prefix = 'attr%s' % attr.pk
+        yield form_class(attribute=attr, initial_value=v, prefix=prefix)
+
  
 @render_template('extra_attributes.html')
 @ajax(method='get', template='extra_attributes.html')
 def extra_attributes(request, lexeme_id, pos, ics):
-  l = Lexeme.all_objects.get(pk=lexeme_id)
-  part_of_speech = PartOfSpeech.objects.get(symbol=pos)
-  ics = InflectionCharacteristic.objects.filter(pk__in=ics)
-  return {
-    'forms': attribute_forms(
-      l, part_of_speech=part_of_speech, ics=ics),
-  }
+    l = Lexeme.all_objects.get(pk=lexeme_id)
+    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
+    ics = InflectionCharacteristic.objects.filter(pk__in=ics)
+    return {
+        'forms': attribute_forms(
+            l, part_of_speech=part_of_speech, ics=ics),
+    }
+
  
 @ajax(method='get')
 def check_attributes(request, lexeme_id, pos, ics):
-  l = Lexeme.all_objects.get(pk=lexeme_id)
-  part_of_speech = PartOfSpeech.objects.get(symbol=pos)
-  ics = InflectionCharacteristic.objects.filter(
-    part_of_speech=part_of_speech, symbol__in=ics)
-  attrs = list(l.attributes(part_of_speech, ics).values_list('pk', flat=True))
-  return {'attrs': attrs}
+    l = Lexeme.all_objects.get(pk=lexeme_id)
+    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
+    ics = InflectionCharacteristic.objects.filter(
+        part_of_speech=part_of_speech, symbol__in=ics)
+    attrs = list(l.attributes(part_of_speech, ics).values_list('pk', flat=True))
+    return {'attrs': attrs}
+
  
 @render_template('lexeme_edit_form.html')
 @ajax(method='get', template='lexeme_edit_form.html')
 def lexeme_edit_form(request, id):
-  to_return = {}
-  l = Lexeme.all_objects.get(pk=id) # bo może być świeżo utworzony
-  if not l.perm(request.user, 'view'):
-    raise AjaxError('access denied')
-  editable = l.perm(request.user, 'change')
-  to_return['editable'] = editable
-  owner = l.owner_vocabulary
-
-  to_return['attribute_forms'] = attribute_forms(l)
-
-  editable_vocabs = editable_vocabularies(request.user)
-  ro_owner = owner not in editable_vocabs
-  to_return['multiple_editable'] = editable and editable_vocabs.count() > 1
-  if ro_owner:
-    # nie pokazujemy wszystkich, tylko te z właściciela
-    ro_qualifiers = l.qualifiers.filter(vocabulary=owner)
-  else:
-    ro_qualifiers = []
-  to_return['owner'] = owner
-  ro_vocabularies = l.visible_vocabularies(request.user).exclude(
-    pk=owner.pk).exclude(pk__in=editable_vocabs)
-  to_return['ro_vocabularies'] = ro_vocabularies
-  to_return['ro_qualifiers'] = ro_qualifiers
-
-  to_return['form'] = LexemeEditForm(
-    instance=l, editable=editable, user=request.user)
-  to_return['id'] = l.pk
-  to_return['part_of_speech'] = l.part_of_speech.symbol
-  to_return['classification_forms'] = make_classification_forms(
-    l, editable=editable)
-
-  lips = l.lexemeinflectionpattern_set.all()
-  to_return['lip_forms'] = [
-    (LIPEditForm(
-      lexeme=l, part_of_speech=l.part_of_speech, instance=lip,
-      prefix='lip' + str(lip.pk), user=request.user, editable=editable),
-     lip.qualifiers.filter(vocabulary=owner) if ro_owner else [])
-    for lip in lips]
-  crs = l.refs_to.order_by('type__index')
-  to_return['cross_references'] = crs
-  return to_return
+    to_return = {}
+    l = Lexeme.all_objects.get(pk=id) # bo może być świeżo utworzony
+    if not l.perm(request.user, 'view'):
+        raise AjaxError('access denied')
+    editable = l.perm(request.user, 'change')
+    to_return['editable'] = editable
+    owner = l.owner_vocabulary
+
+    to_return['attribute_forms'] = attribute_forms(l)
+
+    editable_vocabs = editable_vocabularies(request.user)
+    ro_owner = owner not in editable_vocabs
+    to_return['multiple_editable'] = editable and editable_vocabs.count() > 1
+    if ro_owner:
+        # nie pokazujemy wszystkich, tylko te z właściciela
+        ro_qualifiers = l.qualifiers.filter(vocabulary=owner)
+    else:
+        ro_qualifiers = []
+    to_return['owner'] = owner
+    ro_vocabularies = l.visible_vocabularies(request.user).exclude(
+        pk=owner.pk).exclude(pk__in=editable_vocabs)
+    to_return['ro_vocabularies'] = ro_vocabularies
+    to_return['ro_qualifiers'] = ro_qualifiers
+
+    to_return['form'] = LexemeEditForm(
+        instance=l, editable=editable, user=request.user)
+    to_return['id'] = l.pk
+    to_return['part_of_speech'] = l.part_of_speech.symbol
+    to_return['classification_forms'] = make_classification_forms(
+        l, editable=editable)
+
+    lips = l.lexemeinflectionpattern_set.all()
+    to_return['lip_forms'] = [
+        (LIPEditForm(
+            lexeme=l, part_of_speech=l.part_of_speech, instance=lip,
+            prefix='lip' + str(lip.pk), user=request.user, editable=editable),
+         lip.qualifiers.filter(vocabulary=owner) if ro_owner else [])
+        for lip in lips]
+    crs = l.refs_to.order_by('type__index')
+    to_return['cross_references'] = crs
+    return to_return
+
  
 @ajax(method='get')
 def check_classifications(request, owner_id, pos):
-  part_of_speech = PartOfSpeech.objects.get(symbol=pos)
-  owner = Vocabulary.objects.get(pk=owner_id)
-  classifications = owner.classifications.filter(
-    parts_of_speech=part_of_speech)
-  return {'classifications': list(classifications.values_list('pk', flat=True))}
+    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
+    owner = Vocabulary.objects.get(pk=owner_id)
+    classifications = owner.classifications.filter(
+        parts_of_speech=part_of_speech)
+    return {
+    'classifications': list(classifications.values_list('pk', flat=True))}
+
  
 def make_classification_forms(lexeme, vocabulary=None, part_of_speech=None,
                               editable=True):
-  if not vocabulary:
-    vocabulary = lexeme.owner_vocabulary
-  if not part_of_speech:
-    part_of_speech = lexeme.part_of_speech
-  classifications = vocabulary.classifications.filter(
-    parts_of_speech=part_of_speech)
-  classification_forms = []
-  for c in classifications:
-    values = lexeme.classification_values(c)
-    classification_forms.append(
-      ClassificationForm(
-        classification=c, values=values, prefix='cl' + str(c.pk),
-        editable=editable))
-  return classification_forms
+    if not vocabulary:
+        vocabulary = lexeme.owner_vocabulary
+    if not part_of_speech:
+        part_of_speech = lexeme.part_of_speech
+    classifications = vocabulary.classifications.filter(
+        parts_of_speech=part_of_speech)
+    classification_forms = []
+    for c in classifications:
+        values = lexeme.classification_values(c)
+        classification_forms.append(
+            ClassificationForm(
+                classification=c, values=values, prefix='cl' + str(c.pk),
+                editable=editable))
+    return classification_forms
+
  
 @render_template('classification_forms.html')
 @ajax(method='get', template='classification_forms.html')
 def classification_forms(request, lexeme_id, vocab_id, pos):
-  l = Lexeme.objects.get(pk=lexeme_id)
-  part_of_speech = PartOfSpeech.objects.get(symbol=pos)
-  if vocab_id:
-    vocab = Vocabulary.objects.get(pk=vocab_id)
-  else:
-    vocab = None
-  forms = make_classification_forms(l, vocab, part_of_speech)
-  return {'forms': forms}
+    l = Lexeme.objects.get(pk=lexeme_id)
+    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
+    if vocab_id:
+        vocab = Vocabulary.objects.get(pk=vocab_id)
+    else:
+        vocab = None
+    forms = make_classification_forms(l, vocab, part_of_speech)
+    return {'forms': forms}
+
  
 @render_template('lexeme_edit_form_row.html')
 @ajax(method='get', template='lexeme_edit_form_row.html')
 def new_lip_edit_row(request, lexeme_id, pos_id, num):
-  l = Lexeme.all_objects.get(pk=lexeme_id)
-  if not l.perm(request.user, 'change'):
-    raise AjaxError('access denied')
-  if not pos_id:
-    raise AjaxError(u'Nieokreślona część mowy.')
-  pos = PartOfSpeech.objects.get(pk=pos_id)
-  lip_form = LIPEditForm(
-    lexeme=l, part_of_speech=pos, prefix='lip_add_%s' % num, user=request.user)
-  return {'lip_form': lip_form, 'editable': True}
+    l = Lexeme.all_objects.get(pk=lexeme_id)
+    if not l.perm(request.user, 'change'):
+        raise AjaxError('access denied')
+    if not pos_id:
+        raise AjaxError(u'Nieokreślona część mowy.')
+    pos = PartOfSpeech.objects.get(pk=pos_id)
+    lip_form = LIPEditForm(
+        lexeme=l, part_of_speech=pos, prefix='lip_add_%s' % num,
+        user=request.user)
+    return {'lip_form': lip_form, 'editable': True}
+
  
 @render('cross_reference_row.html')
 @ajax(method='get', encode_result=False)
 def new_cross_reference_row(request, id, pos_id):
-  l = Lexeme.objects.get(pk=id)
-  if not l.perm(request.user, 'change'):
-    raise AjaxError('access denied')
-  pos = PartOfSpeech.objects.get(pk=pos_id)
-  cr_form = CrossReferenceForm(lexeme=l, pos=pos, prefix='cr_add_NUM')
-  return {'cr_form': cr_form, 'editable': True}
+    l = Lexeme.objects.get(pk=id)
+    if not l.perm(request.user, 'change'):
+        raise AjaxError('access denied')
+    pos = PartOfSpeech.objects.get(pk=pos_id)
+    cr_form = CrossReferenceForm(lexeme=l, pos=pos, prefix='cr_add_NUM')
+    return {'cr_form': cr_form, 'editable': True}
+
  
 @ajax(method='post')
 def update_lexeme(request, form_data, mask=''):
-  form_dict = dict((x['name'], x['value']) for x in form_data)
-  l = Lexeme.all_objects.get(pk=form_dict['id'])
-  if not l.perm(request.user, 'view'):
-    raise AjaxError('access denied')
-  owner = l.owner_vocabulary
-  created = l.entry == ''
-  if not l.perm(request.user, 'change'):
-    return update_lexeme_qualifiers(
-      l, request.user, form_dict, form_data)
-  form = LexemeEditForm(data=form_dict, instance=l, user=request.user)
-  if form.is_valid():
-    l = form.save()
-    l.responsible = request.user
-    l.deleted = False
-    l.fix_homonym_number()
-    l.save()
-  else:
-    raise AjaxError(error_messages(form))
-
-  for vocab in editable_vocabularies(request.user):
-    if vocab != owner:
-      vocab.set_lexeme(l, vocab in form.cleaned_data['vocabularies'])
-  new_owner = form.cleaned_data.get('new_owner')
-  if new_owner and new_owner != owner:
-    l.change_owner(new_owner)
-    l.save()
-  for qualifier in form.fields['qualifiers'].queryset:
-    qualifier.set_for(l, qualifier in form.cleaned_data['qualifiers'])
-
-  classifications = l.owner_vocabulary.classifications.filter(
-    parts_of_speech=l.part_of_speech)
-  for c in classifications:
-    classification_form = ClassificationForm(
-      data=form_dict, classification=c, prefix='cl' + str(c.pk))
-    if classification_form.is_valid():
-      cvs = ClassificationValue.objects.filter(
-        pk__in=classification_form.cleaned_data['values'])
-      l_cvs = l.classification_values(c)
-      for cv in l_cvs:
-        if cv.pk not in classification_form.cleaned_data['values']:
-          cv.remove_lexeme(l)
-      for cv in cvs:
-        if cv not in l_cvs:
-          cv.add_lexeme(l)
+    form_dict = dict((x['name'], x['value']) for x in form_data)
+    l = Lexeme.all_objects.get(pk=form_dict['id'])
+    if not l.perm(request.user, 'view'):
+        raise AjaxError('access denied')
+    owner = l.owner_vocabulary
+    created = l.entry == ''
+    if not l.perm(request.user, 'change'):
+        return update_lexeme_qualifiers(
+            l, request.user, form_dict, form_data)
+    form = LexemeEditForm(data=form_dict, instance=l, user=request.user)
+    if form.is_valid():
+        l = form.save()
+        l.responsible = request.user
+        l.deleted = False
+        l.fix_homonym_number()
+        l.save()
     else:
-      raise AjaxError(error_messages(classification_form))
-  for cv in l.classificationvalue_set.all():
-    if cv.classification not in classifications:
-      cv.remove_lexeme(l)
-
-  extra_attributes = l.attributes()
-  for attr in extra_attributes:
-    prefix = 'attr' + str(attr.pk)
-    attr_values = attr.values.filter(lexemes=l)
-    if not attr.multiple:
-      assert len(attr_values) <= 1
-      if not attr.closed:
-        attr_form = LexemeOpenAttributeForm(
-          attribute=attr, data=form_dict, prefix=prefix)
-      else:
-        attr_form = LexemeClosedAttributeForm(
-          attribute=attr, data=form_dict, prefix=prefix)
-      if attr_form.is_valid():
-        if not attr.closed:
-          value = attr_form.cleaned_data['value']
-          av = LexemeAttributeValue.objects.get_or_create(
-            attribute=attr, value=value)
+        raise AjaxError(error_messages(form))
+
+    for vocab in editable_vocabularies(request.user):
+        if vocab != owner:
+            vocab.set_lexeme(l, vocab in form.cleaned_data['vocabularies'])
+    new_owner = form.cleaned_data.get('new_owner')
+    if new_owner and new_owner != owner:
+        l.change_owner(new_owner)
+        l.save()
+    for qualifier in form.fields['qualifiers'].queryset:
+        qualifier.set_for(l, qualifier in form.cleaned_data['qualifiers'])
+
+    classifications = l.owner_vocabulary.classifications.filter(
+        parts_of_speech=l.part_of_speech)
+    for c in classifications:
+        classification_form = ClassificationForm(
+            data=form_dict, classification=c, prefix='cl' + str(c.pk))
+        if classification_form.is_valid():
+            cvs = ClassificationValue.objects.filter(
+                pk__in=classification_form.cleaned_data['values'])
+            l_cvs = l.classification_values(c)
+            for cv in l_cvs:
+                if cv.pk not in classification_form.cleaned_data['values']:
+                    cv.remove_lexeme(l)
+            for cv in cvs:
+                if cv not in l_cvs:
+                    cv.add_lexeme(l)
         else:
-          av = attr_form.cleaned_data['value']
-        if not attr_values or attr_values.get() != av:
-          for av1 in attr_values:
-            av1.remove_lexeme(l)
-          av.add_lexeme(l)
-    else:
-      attr_form = LexemeMultipleAttributeForm(
-        attribute=attr, data=form_dict, prefix=prefix)
-      if attr_form.is_valid():
-        new_values = attr_form.cleaned_data['value']
-        for av in set(attr_values) - set(new_values):
-          av.remove_lexeme(l)
-        for av in set(new_values) - set(attr_values):
-          av.add_lexeme(l)
-  for av in l.lexemeattributevalue_set.all():
-    if av.attribute not in extra_attributes:
-      av.remove_lexeme(l)
-
-  for prefix in form_dict['deleted']:
-    pk = int(prefix[3:])
-    LexemeInflectionPattern.objects.get(pk=pk).delete()
-  for cr_pk in form_dict['deleted_cr']:
-    CrossReference.objects.get(pk=cr_pk).delete()
-  submitted_lips = []
-  submitted_crs = []
-  for pair in form_data:
-    # może (?) się psuć, jeśli jest zły charfl
-    name = pair['name']
-    prefix = name.split('-')[0]
-    if name.startswith('lip') and prefix not in submitted_lips:
-      submitted_lips.append(prefix)
-      if prefix.startswith('lip_add'):
-        lip = LexemeInflectionPattern()
-        lip.lexeme = l
-      else:
+            raise AjaxError(error_messages(classification_form))
+    for cv in l.classificationvalue_set.all():
+        if cv.classification not in classifications:
+            cv.remove_lexeme(l)
+
+    extra_attributes = l.attributes()
+    for attr in extra_attributes:
+        prefix = 'attr' + str(attr.pk)
+        attr_values = attr.values.filter(lexemes=l)
+        if not attr.multiple:
+            assert len(attr_values) <= 1
+            if not attr.closed:
+                attr_form = LexemeOpenAttributeForm(
+                    attribute=attr, data=form_dict, prefix=prefix)
+            else:
+                attr_form = LexemeClosedAttributeForm(
+                    attribute=attr, data=form_dict, prefix=prefix)
+            if attr_form.is_valid():
+                if not attr.closed:
+                    value = attr_form.cleaned_data['value']
+                    av = LexemeAttributeValue.objects.get_or_create(
+                        attribute=attr, value=value)
+                else:
+                    av = attr_form.cleaned_data['value']
+                if not attr_values or attr_values.get() != av:
+                    for av1 in attr_values:
+                        av1.remove_lexeme(l)
+                    av.add_lexeme(l)
+        else:
+            attr_form = LexemeMultipleAttributeForm(
+                attribute=attr, data=form_dict, prefix=prefix)
+            if attr_form.is_valid():
+                new_values = attr_form.cleaned_data['value']
+                for av in set(attr_values) - set(new_values):
+                    av.remove_lexeme(l)
+                for av in set(new_values) - set(attr_values):
+                    av.add_lexeme(l)
+    for av in l.lexemeattributevalue_set.all():
+        if av.attribute not in extra_attributes:
+            av.remove_lexeme(l)
+
+    for prefix in form_dict['deleted']:
         pk = int(prefix[3:])
-        lip = LexemeInflectionPattern.objects.get(pk=pk)
-      form_dict[prefix + '-qualifiers'] = get_list(
-        form_data, prefix + '-qualifiers')
-      lip_form = LIPEditForm(
-        lexeme=l, part_of_speech=l.part_of_speech, data=form_dict, prefix=prefix,
-        instance=lip, user=request.user, index=len(submitted_lips))
-      if lip_form.is_valid():
-        lip = lip_form.save()
-        lip.root = l.get_root(lip.pattern, lip.inflection_characteristic)
-        if lip.root is None:
-          raise AjaxError(u'Niepasujące zakończenie formy podstawowej.')
-        for qualifier in lip_form.fields['qualifiers'].queryset:
-          qualifier.set_for(
-            lip, qualifier in lip_form.cleaned_data['qualifiers'])
-        lip.save()
-      else:
-        raise AjaxError(error_messages(lip_form))
-    if name.startswith('cr_add') and prefix not in submitted_crs:
-      submitted_crs.append(prefix)
-      cr_form = CrossReferenceForm(data=form_dict, prefix=prefix)
-      if cr_form.is_valid():
-        cr_form.save()
-      else:
-        raise AjaxError(error_messages(cr_form))
-  if len(submitted_lips) == 0 and l.status != 'cand':
-    raise AjaxError(u'Wybierz odmianę lub ustaw status "kandydat".')
-  l.refresh_forms()
-  if created:
-    sort_rules = json.loads(request.session['sort_rules'])
-    filters = json.loads(request.session['filters'])
-    query = JqGridQuery(
-      filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-    key = cache_key(query)
-    pk_list = cache.get(key)
-    if pk_list:
-      pk_list = [l.pk] + pk_list
-      cache.set(key, pk_list)
-  return {}
+        LexemeInflectionPattern.objects.get(pk=pk).delete()
+    for cr_pk in form_dict['deleted_cr']:
+        CrossReference.objects.get(pk=cr_pk).delete()
+    submitted_lips = []
+    submitted_crs = []
+    for pair in form_data:
+        # może (?) się psuć, jeśli jest zły charfl
+        name = pair['name']
+        prefix = name.split('-')[0]
+        if name.startswith('lip') and prefix not in submitted_lips:
+            submitted_lips.append(prefix)
+            if prefix.startswith('lip_add'):
+                lip = LexemeInflectionPattern()
+                lip.lexeme = l
+            else:
+                pk = int(prefix[3:])
+                lip = LexemeInflectionPattern.objects.get(pk=pk)
+            form_dict[prefix + '-qualifiers'] = get_list(
+                form_data, prefix + '-qualifiers')
+            lip_form = LIPEditForm(
+                lexeme=l, part_of_speech=l.part_of_speech, data=form_dict,
+                prefix=prefix,
+                instance=lip, user=request.user, index=len(submitted_lips))
+            if lip_form.is_valid():
+                lip = lip_form.save()
+                lip.root = l.get_root(lip.pattern,
+                                      lip.inflection_characteristic)
+                if lip.root is None:
+                    raise AjaxError(
+                        u'Niepasujące zakończenie formy podstawowej.')
+                for qualifier in lip_form.fields['qualifiers'].queryset:
+                    qualifier.set_for(
+                        lip, qualifier in lip_form.cleaned_data['qualifiers'])
+                lip.save()
+            else:
+                raise AjaxError(error_messages(lip_form))
+        if name.startswith('cr_add') and prefix not in submitted_crs:
+            submitted_crs.append(prefix)
+            cr_form = CrossReferenceForm(data=form_dict, prefix=prefix)
+            if cr_form.is_valid():
+                cr_form.save()
+            else:
+                raise AjaxError(error_messages(cr_form))
+    if len(submitted_lips) == 0 and l.status != 'cand':
+        raise AjaxError(u'Wybierz odmianę lub ustaw status "kandydat".')
+    l.refresh_forms()
+    if created:
+        sort_rules = json.loads(request.session['sort_rules'])
+        filters = json.loads(request.session['filters'])
+        query = JqGridQuery(
+            filters=filters, sort_rules=sort_rules, mask=mask,
+            user=request.user)
+        key = cache_key(query)
+        pk_list = cache.get(key)
+        if pk_list:
+            pk_list = [l.pk] + pk_list
+            cache.set(key, pk_list)
+    return {}
+
  
 def update_lexeme_qualifiers(lexeme, user, form_dict, form_data):
-  owner = lexeme.owner_vocabulary
-  editable_vocabs = editable_vocabularies(user).exclude(pk=owner.pk)
-  l_editable_vocabs = lexeme.editable_vocabularies(user)
-  qualifiers = Qualifier.objects.filter(vocabulary__in=l_editable_vocabs)
-  for qualifier in qualifiers:
-    qualifier.set_for(
-      lexeme, unicode(qualifier.pk) in form_dict['qualifiers'])
-  for vocab in editable_vocabs:
-    vocab.set_lexeme(lexeme, vocab.pk in form_dict['vocabularies'])
-  submitted_lips = []
-  for pair in form_data:
-    name = pair['name']
-    prefix = name.split('-')[0]
-    if name.startswith('lip') and prefix not in submitted_lips:
-      submitted_lips.append(prefix)
-      pk = int(prefix[3:])
-      lip = LexemeInflectionPattern.objects.get(pk=pk)
-      lip_qualifiers = get_list(form_data, prefix + '-qualifiers')
-      for qualifier in qualifiers:
-        qualifier.set_for(lip, unicode(qualifier.pk) in lip_qualifiers)
-  return {}
+    owner = lexeme.owner_vocabulary
+    editable_vocabs = editable_vocabularies(user).exclude(pk=owner.pk)
+    l_editable_vocabs = lexeme.editable_vocabularies(user)
+    qualifiers = Qualifier.objects.filter(vocabulary__in=l_editable_vocabs)
+    for qualifier in qualifiers:
+        qualifier.set_for(
+            lexeme, unicode(qualifier.pk) in form_dict['qualifiers'])
+    for vocab in editable_vocabs:
+        vocab.set_lexeme(lexeme, vocab.pk in form_dict['vocabularies'])
+    submitted_lips = []
+    for pair in form_data:
+        name = pair['name']
+        prefix = name.split('-')[0]
+        if name.startswith('lip') and prefix not in submitted_lips:
+            submitted_lips.append(prefix)
+            pk = int(prefix[3:])
+            lip = LexemeInflectionPattern.objects.get(pk=pk)
+            lip_qualifiers = get_list(form_data, prefix + '-qualifiers')
+            for qualifier in qualifiers:
+                qualifier.set_for(lip, unicode(qualifier.pk) in lip_qualifiers)
+    return {}
+
  
 def get_list(form_data, name):
-  return [pair['value'] for pair in form_data if pair['name'] == name]
+    return [pair['value'] for pair in form_data if pair['name'] == name]
+
  
 @ajax(method='post')
 def delete_lexeme(request, lexeme_id):
-  lexeme_id = int(lexeme_id)
-  l = Lexeme.objects.get(pk=lexeme_id)
-  if not l.perm(request.user, 'change'):
-    raise AjaxError('access denied')
-  l.deleted = True
-  l.save()
-  key_list = cache.get('key_list', [])
-  for key in key_list:
-    pk_list = cache.get(key)
-    if pk_list and lexeme_id in pk_list:
-      pk_list.remove(lexeme_id)
-      cache.set(key, pk_list)
-  return {}
+    lexeme_id = int(lexeme_id)
+    l = Lexeme.objects.get(pk=lexeme_id)
+    if not l.perm(request.user, 'change'):
+        raise AjaxError('access denied')
+    l.deleted = True
+    l.save()
+    key_list = cache.get('key_list', [])
+    for key in key_list:
+        pk_list = cache.get(key)
+        if pk_list and lexeme_id in pk_list:
+            pk_list.remove(lexeme_id)
+            cache.set(key, pk_list)
+    return {}
+
  
 @ajax(method='get')
 def check_pos(request, pos_id, ic_id):
-  ic = InflectionCharacteristic.objects.get(pk=ic_id)
-  if InflectionCharacteristic.objects.filter(
-       symbol=ic.symbol, part_of_speech__pk=pos_id):
-    return {'answer': 'yes'}
-  else:
-    return {'answer': 'no'}
+    ic = InflectionCharacteristic.objects.get(pk=ic_id)
+    if InflectionCharacteristic.objects.filter(
+            symbol=ic.symbol, part_of_speech__pk=pos_id):
+        return {'answer': 'yes'}
+    else:
+        return {'answer': 'no'}
+
  
 @ajax(method='get')
 def check_pattern(request, pattern_name, ic_id):
-  lips = LexemeInflectionPattern.objects.filter(
-    inflection_characteristic__pk=ic_id, pattern__name=pattern_name)
-  lips = lips.exclude(lexeme__status='cand')
-  if lips.exists():
-    return {'answer': 'yes'}
-  else:
-    return {'answer': 'no'}
+    lips = LexemeInflectionPattern.objects.filter(
+        inflection_characteristic__pk=ic_id, pattern__name=pattern_name)
+    lips = lips.exclude(lexeme__status='cand')
+    if lips.exists():
+        return {'answer': 'yes'}
+    else:
+        return {'answer': 'no'}
+
  
 @ajax(method='get')
 def get_ics(request, pos_id):
-  return {'ics': list(InflectionCharacteristic.objects.filter(
-                        part_of_speech__pk=pos_id).values_list('pk', 'symbol'))}
+    return {'ics': list(InflectionCharacteristic.objects.filter(
+        part_of_speech__pk=pos_id).values_list('pk', 'symbol'))}
+
  
 START_ID = 1000000
  
+
 @ajax(method='post')
 def create_lexeme(request, vocab_id):
-  owner = Vocabulary.objects.get(pk=vocab_id)
-  if request.user not in owner.all_editors():
-    raise AjaxError('access denied')
-  next_id = Lexeme.all_objects.filter(
-    pk__gte=START_ID).aggregate(Max('id'))['id__max']
-  next_id = next_id + 1 if next_id else START_ID
-  l = Lexeme()
-  l.id = next_id
-  l.homonym_number = 1 # zanim zostanie faktycznie stworzony
-  l.part_of_speech = PartOfSpeech.objects.get(symbol='subst')
-  l.owner_vocabulary = owner
-  l.status = 'cand'
-  l.responsible = request.user
-  l.deleted = True # proste i genialne!
-  l.save()
-  owner.add_lexeme(l)
-  return {'id': l.id}
+    owner = Vocabulary.objects.get(pk=vocab_id)
+    if request.user not in owner.all_editors():
+        raise AjaxError('access denied')
+    next_id = Lexeme.all_objects.filter(
+        pk__gte=START_ID).aggregate(Max('id'))['id__max']
+    next_id = next_id + 1 if next_id else START_ID
+    l = Lexeme()
+    l.id = next_id
+    l.homonym_number = 1 # zanim zostanie faktycznie stworzony
+    l.part_of_speech = PartOfSpeech.objects.get(symbol='subst')
+    l.owner_vocabulary = owner
+    l.status = 'cand'
+    l.responsible = request.user
+    l.deleted = True # proste i genialne!
+    l.save()
+    owner.add_lexeme(l)
+    return {'id': l.id}
+
  
 @ajax(method='get', login_required=True)
 def homonym_count(request, entry, lexeme_id):
-  lexemes = Lexeme.objects.filter(entry=entry).exclude(pk=lexeme_id)
-  lexemes = filter_visible(lexemes, request.user)
-  return {'count': lexemes.count()}
+    lexemes = Lexeme.objects.filter(entry=entry).exclude(pk=lexeme_id)
+    lexemes = filter_visible(lexemes, request.user)
+    return {'count': lexemes.count()}
+
  
 @ajax(method='get', login_required=True)
 def cr_homonyms(request, entry, cr_type):
-  cr_type = CrossReferenceType.objects.get(pk=cr_type)
-  lexemes = Lexeme.objects.filter(entry=entry, part_of_speech=cr_type.to_pos)
-  lexemes_data = [
-    {
-      'homonym_number': l.homonym_number,
-      'lip_data': l.lip_data(),
-    } for l in lexemes.order_by('homonym_number')
-  ]
-  return {'lexemes': lexemes_data}
+    cr_type = CrossReferenceType.objects.get(pk=cr_type)
+    lexemes = Lexeme.objects.filter(entry=entry, part_of_speech=cr_type.to_pos)
+    lexemes_data = [
+        {
+            'homonym_number': l.homonym_number,
+            'lip_data': l.lip_data(),
+        } for l in lexemes.order_by('homonym_number')
+    ]
+    return {'lexemes': lexemes_data}
  
  
 @render('new_action_row.html')
 @ajax(method='get', login_required=True, encode_result=False)
 def new_action_row(request):
-  form = ActionFieldForm(prefix='action_NUM')
-  return {'form': form}
+    form = ActionFieldForm(prefix='action_NUM')
+    return {'form': form}
+
  
 @ajax(method='get', login_required=True)
 def dynamic_action_fields(request, field_name):
-  action_form, value_form = dict(ACTION_FIELDS)[field_name][1:3]
-  return {
-    'action': action_form()['action'].as_widget(),
-    'value': value_form(request)['value'].as_widget(),
-  }
+    action_form, value_form = dict(ACTION_FIELDS)[field_name][1:3]
+    return {
+        'action': action_form()['action'].as_widget(),
+        'value': value_form(request)['value'].as_widget(),
+    }
+
  
 @ajax(method='post', login_required=True)
 def execute_group_actions(request, actions, filters):
-  if not request.user.has_perm('dictionary.change_lexeme'):
-    raise AjaxError('access denied')
-  if isinstance(filters, basestring):
-    filters = json.loads(filters)
-  query = JqGridQuery(
-    filters=filters, sort_rules=[], mask='', user=request.user)
-  pk_list = get_pk_list(query)
-  lexemes = Lexeme.objects.filter(pk__in=pk_list)
-  for l in lexemes:
-    for action in actions:
-      field = action['field']
-      if field == 'status':
-        # action['type'] == 'set'
-        l.status = action['value']
-      elif field == 'using_vocabulary':
-        vocab = Vocabulary.objects.get(pk=action['value'])
-        if action['type'] == 'add':
-          vocab.add_lexeme(l)
-        else: # 'remove'
-          if vocab != l.owner_vocabulary:
-            vocab.remove_lexeme(l)
-      else: # field == 'lexeme_qualifier'
-        qual = Qualifier.objects.get(pk=action['value'])
-        # a co jeśli koliduje z innym?
-        if action['type'] == 'add':
-          l.qualifiers.add(qual) #add
-        else:
-          l.qualifiers.remove(qual) #add
-    l.save()
-  #print repr(actions), repr(filters)
-  return {}
+    if not request.user.has_perm('dictionary.change_lexeme'):
+        raise AjaxError('access denied')
+    if isinstance(filters, basestring):
+        filters = json.loads(filters)
+    query = JqGridQuery(
+        filters=filters, sort_rules=[], mask='', user=request.user)
+    pk_list = get_pk_list(query)
+    lexemes = Lexeme.objects.filter(pk__in=pk_list)
+    for l in lexemes:
+        for action in actions:
+            field = action['field']
+            if field == 'status':
+                # action['type'] == 'set'
+                l.status = action['value']
+            elif field == 'using_vocabulary':
+                vocab = Vocabulary.objects.get(pk=action['value'])
+                if action['type'] == 'add':
+                    vocab.add_lexeme(l)
+                else: # 'remove'
+                    if vocab != l.owner_vocabulary:
+                        vocab.remove_lexeme(l)
+            else: # field == 'lexeme_qualifier'
+                qual = Qualifier.objects.get(pk=action['value'])
+                # a co jeśli koliduje z innym?
+                if action['type'] == 'add':
+                    l.qualifiers.add(qual) #add
+                else:
+                    l.qualifiers.remove(qual) #add
+        l.save()
+        #print repr(actions), repr(filters)
+    return {}
  
  
 @ajax(method='post')
 def save_columns(request, col_model, col_names, remap):
-  request.session['colModel'] = col_model
-  request.session['colNames'] = col_names
-  request.session['remap'] = remap
-  return {}
+    request.session['colModel'] = col_model
+    request.session['colNames'] = col_names
+    request.session['remap'] = remap
+    return {}
  
  
 @ajax(method='post')
 def add_vocabulary(request, name):
-  if not request.user.has_perm('dictionary.manage_vocabulary'):
-    raise AjaxError('access denied')
-  vocab = Vocabulary.objects.create(id=name)
-  vocab.managers.add(request.user) #add
-  return {}
+    if not request.user.has_perm('dictionary.manage_vocabulary'):
+        raise AjaxError('access denied')
+    vocab = Vocabulary.objects.create(id=name)
+    vocab.managers.add(request.user) #add
+    return {}
  
 # nieużywane
 @ajax(method='get')
 def vocabulary_permissions(request, vocab_id):
-  if not request.user.has_perm('dictionary.manage_vocabulary'):
-    raise AjaxError('access denied')
-  vocab = Vocabulary.objects.get(id=vocab_id)
-  return {
-    'managers': list(vocab.all_managers().values_list('pk', flat=True)),
-    'viewers': list(vocab.all_viewers().values_list('pk', flat=True)),
-    'editors': list(vocab.editors.values_list('pk', flat=True)),
-  }
+    if not request.user.has_perm('dictionary.manage_vocabulary'):
+        raise AjaxError('access denied')
+    vocab = Vocabulary.objects.get(id=vocab_id)
+    return {
+        'managers': list(vocab.all_managers().values_list('pk', flat=True)),
+        'viewers': list(vocab.all_viewers().values_list('pk', flat=True)),
+        'editors': list(vocab.editors.values_list('pk', flat=True)),
+    }
+
  
 @ajax(method='post')
 def set_vocabulary_permission(request, name, vocab_id, perm, on):
-  if not request.user.has_perm('dictionary.manage_vocabulary'):
-    raise AjaxError('access denied')
-  vocab = Vocabulary.objects.get(id=name)
-  user = User.objects.get(pk=vocab_id)
-  if perm == 'view':
-    related_manager = vocab.viewers
-  elif perm == 'change':
-    related_manager = vocab.editors
-  else: # type == 'manage'
-    related_manager = vocab.managers
-  if on:
-    related_manager.add(user) #add
-  else:
-    related_manager.remove(user) #add
-  return {}
 \ No newline at end of file
+    if not request.user.has_perm('dictionary.manage_vocabulary'):
+        raise AjaxError('access denied')
+    vocab = Vocabulary.objects.get(id=name)
+    user = User.objects.get(pk=vocab_id)
+    if perm == 'view':
+        related_manager = vocab.viewers
+    elif perm == 'change':
+        related_manager = vocab.editors
+    else: # type == 'manage'
+        related_manager = vocab.managers
+    if on:
+        related_manager.add(user) #add
+    else:
+        related_manager.remove(user) #add
+    return {}
 \ No newline at end of file
@@ -2,44 +2,44 @@
  
 from common.util import json_encode
 from dictionary.models import Pattern, Ending, BaseFormLabel, PatternType, \
-  editable_qualifiers, readonly_vocabularies
+    editable_qualifiers, readonly_vocabularies
 from dictionary.forms import PatternEditForm, PatternTypeForm, QualifierForm
 from dictionary.ajax_jqgrid import JqGridAjax, JqGridQuery
 from common.decorators import render, ajax, AjaxError, render_template
  
  
 class PatternGrid(JqGridAjax):
-  model = Pattern
-  search_field = 'name'
-
-  @staticmethod
-  def filter_special_case(filter, lookup, negated, queryset):
-    field = filter['field']
-    if field == 'part_of_speech':
-      field = 'type__lexical_class__symbol'
-    elif field == 'type':
-      field = 'type__symbol'
-    return False, field, queryset
-
-  @staticmethod
-  def apply_mask(patterns, mask, sort_rules):
-    return patterns.filter(name__istartswith=mask)
-
-  @staticmethod
-  def response_row(pattern):
-    return [
-      pattern.name,
-      pattern.type.symbol,
-      pattern.type.lexical_class.symbol,
-    ]
+    model = Pattern
+    search_field = 'name'
+
+    @staticmethod
+    def filter_special_case(filter, lookup, negated, queryset):
+        field = filter['field']
+        if field == 'part_of_speech':
+            field = 'type__lexical_class__symbol'
+        elif field == 'type':
+            field = 'type__symbol'
+        return False, field, queryset
+
+    @staticmethod
+    def apply_mask(patterns, mask, sort_rules):
+        return patterns.filter(name__istartswith=mask)
+
+    @staticmethod
+    def response_row(pattern):
+        return [
+            pattern.name,
+            pattern.type.symbol,
+            pattern.type.lexical_class.symbol,
+        ]
  
  
 # Zapytanie o indeks wiersza o pewnym id przy danym sortowaniu
 @ajax(method='get')
 def find_id(request, id, sort_rules, mask, filters=None):
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  return PatternGrid.find_id(id, query)
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    return PatternGrid.find_id(id, query)
  
  
 # Zapytanie o id oraz indeks wiersza przy danym sortowaniu
@@ -47,104 +47,109 @@ def find_id(request, id, sort_rules, mask, filters=None):
 # 'selected_id' < 0, jeśli takiego nie ma
 @ajax(method='get')
 def get_location(request, sort_rules, filters=None, mask=''):
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  return PatternGrid.get_location(query)
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    return PatternGrid.get_location(query)
  
  
 @ajax(method='get')
 def get_patterns(request, page, rows, sort_rules, filters=None, mask='',
                  target_page=0, totalrows=0):
-  request.session['pattern-sort_rules'] = json_encode(sort_rules)
-  request.session['pattern-filters'] = json_encode(filters)
-  page = target_page or page
-  limit = totalrows or rows
-  query = JqGridQuery(
-    filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
-  return PatternGrid.get_page(page, limit, query)
+    request.session['pattern-sort_rules'] = json_encode(sort_rules)
+    request.session['pattern-filters'] = json_encode(filters)
+    page = target_page or page
+    limit = totalrows or rows
+    query = JqGridQuery(
+        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
+    return PatternGrid.get_page(page, limit, query)
  
  
 @render_template('pattern_edit_form.html')
 @ajax(method='get', template='pattern_edit_form.html')
 def pattern_edit_form(request, id):
-  if not request.user.has_perm('dictionary.view_pattern'):
-    raise AjaxError('access denied')
-  to_return = {}
-  p = Pattern.objects.get(pk=id)
-  editable = request.user.has_perm('dictionary.change_pattern')
-  to_return['form'] = PatternEditForm(instance=p, editable=editable)
-  to_return['type_form'] = PatternTypeForm(instance=p.type, editable=editable)
-  to_return['id'] = p.pk
-  to_return['editable'] = editable
-  bfls = p.type.base_form_labels()
-  ending_groups = dict((bfl, []) for bfl in bfls)
-  endings = p.endings.order_by('base_form_label', 'index')
-  for e in endings:
-    ro_qualifers = e.qualifiers.filter(
-      vocabulary__in=readonly_vocabularies(request.user))
-    q_form = QualifierForm(
-      qualified=e, user=request.user, editable=editable, prefix='end%s' % e.pk)
-    ending_groups[e.base_form_label].append((e, ro_qualifers, q_form))
-  to_return['ending_groups'] = ending_groups
-  return to_return
+    if not request.user.has_perm('dictionary.view_pattern'):
+        raise AjaxError('access denied')
+    to_return = {}
+    p = Pattern.objects.get(pk=id)
+    editable = request.user.has_perm('dictionary.change_pattern')
+    to_return['pattern'] = p
+    to_return['form'] = PatternEditForm(instance=p, editable=editable)
+    to_return['type_form'] = PatternTypeForm(instance=p.type, editable=editable)
+    to_return['editable'] = editable
+    bfls = p.type.base_form_labels()
+    ending_groups = dict((bfl, []) for bfl in bfls)
+    endings = p.endings.order_by('base_form_label', 'index')
+    for e in endings:
+        ro_qualifers = e.qualifiers.filter(
+            vocabulary__in=readonly_vocabularies(request.user))
+        q_form = QualifierForm(
+            qualified=e, user=request.user, editable=editable,
+            prefix='end%s' % e.pk)
+        ending_groups[e.base_form_label].append((e, ro_qualifers, q_form))
+    to_return['ending_groups'] = ending_groups
+    return to_return
  
  
 # mogłoby iść przez js_vars...
 @render('ending_row.html')
 @ajax(method='get', encode_result=False)
-def new_ending_row(request):
-  ending = {'string': '', 'id': 'add-NUM'}
-  form = QualifierForm(user=request.user, prefix='add-NUM')
-  return {'ending': ending, 'editable': True, 'form': form}
+def new_ending_row(request, pattern_id):
+    p = Pattern.objects.get(id=pattern_id)
+    ending = {'string': '', 'id': 'add-NUM'}
+    form = QualifierForm(user=request.user, prefix='add-NUM')
+    return {'ending': ending, 'editable': True, 'form': form, 'pattern': p}
  
  
 @ajax(method='post')
 def update_pattern(request, form_data):
-  if not request.user.has_perm('dictionary.change_pattern'):
-    raise AjaxError('access denied')
-  form_dict = dict((x['name'], x['value']) for x in form_data)
-  p = Pattern.objects.get(pk=form_dict['id'])
-  form = PatternEditForm(data=form_dict, instance=p)
-  type_form = PatternTypeForm(data=form_dict)
-  if type_form.is_valid():
-    type_qs = PatternType.objects.filter(
-      symbol=type_form.cleaned_data['symbol'],
-      lexical_class=type_form.cleaned_data['lexical_class'])
-  else:
-    raise AjaxError('invalid data')
-  if form.is_valid() and len(type_qs) == 1:
-    form.save()
-    p.type = type_qs[0]
-    p.save()
-    for ending_pk in form_dict['deleted']:
-      Ending.objects.get(pk=int(ending_pk)).delete()
-    qualifiers = editable_qualifiers(request.user)
-    for bfl_endings in form_dict['ending_list']:
-      endings_data = bfl_endings['endings']
-      bfl = BaseFormLabel.objects.get(symbol=bfl_endings['base_form_label'])
-      endings = []
-      for index, ending_data in zip(range(1, len(endings_data) + 1), endings_data):
-        quals = set(int(q) for q in ending_data['qualifiers'])
-        if ending_data['id'] == 'add':
-          ending = Ending.objects.create(
-            pattern=p, base_form_label=bfl, string=ending_data['string'],
-            index=index)
-        else:
-          ending = Ending.objects.get(pk=int(ending_data['id']))
-          ending.index = index
-          ending.string = ending_data['string']
-          ending.save()
-        for qualifier in qualifiers:
-          qualifier.set_for(ending, qualifier.pk in quals)
-        endings.append(ending)
-  else:
-    raise AjaxError('invalid data')
-  return {}
+    if not request.user.has_perm('dictionary.change_pattern'):
+        raise AjaxError('access denied')
+    form_dict = dict((x['name'], x['value']) for x in form_data)
+    p = Pattern.objects.get(pk=form_dict['id'])
+    form = PatternEditForm(data=form_dict, instance=p)
+    type_form = PatternTypeForm(data=form_dict)
+    if type_form.is_valid():
+        type_qs = PatternType.objects.filter(
+            symbol=type_form.cleaned_data['symbol'],
+            lexical_class=type_form.cleaned_data['lexical_class'])
+    else:
+        raise AjaxError('invalid data')
+    if form.is_valid() and len(type_qs) == 1:
+        form.save()
+        p.type = type_qs[0]
+        p.save()
+        for ending_pk in form_dict['deleted']:
+            Ending.objects.get(pk=int(ending_pk)).delete()
+        qualifiers = editable_qualifiers(request.user)
+        for bfl_endings in form_dict['ending_list']:
+            endings_data = bfl_endings['endings']
+            bfl = BaseFormLabel.objects.get(
+                symbol=bfl_endings['base_form_label'])
+            endings = []
+            for index, ending_data in zip(range(1, len(endings_data) + 1),
+                                          endings_data):
+                quals = set(int(q) for q in ending_data['qualifiers'])
+                if ending_data['id'] == 'add':
+                    ending = Ending.objects.create(
+                        pattern=p, base_form_label=bfl,
+                        string=ending_data['string'],
+                        index=index)
+                else:
+                    ending = Ending.objects.get(pk=int(ending_data['id']))
+                    ending.index = index
+                    ending.string = ending_data['string']
+                    ending.save()
+                for qualifier in qualifiers:
+                    qualifier.set_for(ending, qualifier.pk in quals)
+                endings.append(ending)
+    else:
+        raise AjaxError('invalid data')
+    return {}
  
  
 @ajax(method='post')
 def save_columns(request, col_model, col_names, remap):
-  request.session['pattern-colModel'] = col_model
-  request.session['pattern-colNames'] = col_names
-  request.session['pattern-remap'] = remap
-  return {}
+    request.session['pattern-colModel'] = col_model
+    request.session['pattern-colNames'] = col_names
+    request.session['pattern-remap'] = remap
+    return {}
@@ -3,82 +3,84 @@
 from common.decorators import render, ajax, AjaxError
 from common.util import suffix, cut_end
 from dictionary.models import Lexeme, LexemeInflectionPattern, Pattern, \
-  InflectionCharacteristic, prepare_table, visible_vocabularies, get_root, \
-  ClassificationValue, Classification, filter_visible_lips
+    InflectionCharacteristic, prepare_table, visible_vocabularies, get_root, \
+    ClassificationValue, Classification, filter_visible_lips
 from dictionary.pattern_blacklist import blacklist
  
 commonness = Classification.objects.get(name=u'pospolitość')
  
 LIP_ROWS = 10
  
+
 def make_list(user, entry, pos, ic, cvs, bl_check):
-  lips = LexemeInflectionPattern.objects.distinct()
-  lips = filter_visible_lips(lips, user)
-  lips = lips.filter(
-    lexeme__part_of_speech__symbol=pos).exclude(lexeme__status='cand')
-  if ic:
-    lips = lips.filter(inflection_characteristic=ic)
-  if cvs:
-    lips = lips.filter(lexeme__classificationvalue__in=cvs)
-  else:
-    lips = lips.exclude(lexeme__classificationvalue=None)
-  lips = lips.order_by('lexeme__entry')
-  feature_sets = set()
-  bad_inflections = set()
-  chosen_lips = []
-  for suf_len in xrange(len(entry), 0, -1):
-    suf = suffix(entry, suf_len)
-    suf_lips = lips.filter(lexeme__entry__endswith=suf)
-    if suf_len < len(entry):
-      suf1 = suffix(entry, suf_len + 1)
-      suf_lips = suf_lips.exclude(lexeme__entry__endswith=suf1)
-    for p0, ic0 in bad_inflections:
-      suf_lips.exclude(pattern=p0, inflection_characteristic=ic0)
-    for p0, ic0 in feature_sets:
-      suf_lips = suf_lips.exclude(
-        pattern=p0, inflection_characteristic=ic0)
-    for lip in suf_lips:
-      #lip = suf_lips[0]
-      p = lip.pattern
-      #suf_lips = suf_lips.exclude(pattern=p)
-      if p.name in blacklist and bl_check: continue
-      if ic:
-        l_ic = ic
-      else:
-        l_ic = lip.inflection_characteristic
-      if (p, l_ic) in bad_inflections: continue
-      if (p, l_ic) in feature_sets: continue
-      if cvs:
-        l_cvs = lip.lexeme.classification_values(commonness) & cvs
-      else:
-        l_cvs = lip.lexeme.classification_values(commonness)
-      if get_root(entry, pos, p, l_ic) is not None:
-        l_root = lip.lexeme.get_root(p, l_ic)
-        l_end = lip.lexeme.entry[len(l_root):]
-        l_entry = u'%s·%s' % (l_root, l_end)
-        if len(l_end) < len(suf):
-          suf = suffix(l_entry, suf_len + 1)
-        chosen_lips.append((lip, l_cvs, cut_end(l_entry, suf), suf))
-        feature_sets.add((p, l_ic))
+    lips = LexemeInflectionPattern.objects.distinct()
+    lips = filter_visible_lips(lips, user)
+    lips = lips.filter(
+        lexeme__part_of_speech__symbol=pos).exclude(lexeme__status='cand')
+    if ic:
+        lips = lips.filter(inflection_characteristic=ic)
+    if cvs:
+        lips = lips.filter(lexeme__classificationvalue__in=cvs)
+    else:
+        lips = lips.exclude(lexeme__classificationvalue=None)
+    lips = lips.order_by('lexeme__entry')
+    feature_sets = set()
+    bad_inflections = set()
+    chosen_lips = []
+    for suf_len in xrange(len(entry), 0, -1):
+        suf = suffix(entry, suf_len)
+        suf_lips = lips.filter(lexeme__entry__endswith=suf)
+        if suf_len < len(entry):
+            suf1 = suffix(entry, suf_len + 1)
+            suf_lips = suf_lips.exclude(lexeme__entry__endswith=suf1)
+        for p0, ic0 in bad_inflections:
+            suf_lips.exclude(pattern=p0, inflection_characteristic=ic0)
+        for p0, ic0 in feature_sets:
+            suf_lips = suf_lips.exclude(
+                pattern=p0, inflection_characteristic=ic0)
+        for lip in suf_lips:
+            #lip = suf_lips[0]
+            p = lip.pattern
+            #suf_lips = suf_lips.exclude(pattern=p)
+            if p.name in blacklist and bl_check: continue
+            if ic:
+                l_ic = ic
+            else:
+                l_ic = lip.inflection_characteristic
+            if (p, l_ic) in bad_inflections: continue
+            if (p, l_ic) in feature_sets: continue
+            if cvs:
+                l_cvs = lip.lexeme.classification_values(commonness) & cvs
+            else:
+                l_cvs = lip.lexeme.classification_values(commonness)
+            if get_root(entry, pos, p, l_ic) is not None:
+                l_root = lip.lexeme.get_root(p, l_ic)
+                l_end = lip.lexeme.entry[len(l_root):]
+                l_entry = u'%s·%s' % (l_root, l_end)
+                if len(l_end) < len(suf):
+                    suf = suffix(l_entry, suf_len + 1)
+                chosen_lips.append((lip, l_cvs, cut_end(l_entry, suf), suf))
+                feature_sets.add((p, l_ic))
+                if len(chosen_lips) == LIP_ROWS:
+                    break
+            else:
+                bad_inflections.add((p, l_ic))
         if len(chosen_lips) == LIP_ROWS:
-          break
-      else:
-        bad_inflections.add((p, l_ic))
-    if len(chosen_lips) == LIP_ROWS:
-      break
-  return chosen_lips
+            break
+    return chosen_lips
+
  
 @ajax(method='get', template='prompter_list.html')
 def prompter_list(request, entry, pos_id, ic_id, commonness_ids,
                   ic_check, cv_check, bl_check):
-  if ic_check:
-    ic = InflectionCharacteristic.objects.get(pk=ic_id)
-  else:
-    ic = None
-  if cv_check: # and commonness not in ('undefined', 'None'):
-    cvs = ClassificationValue.objects.filter(pk__in=commonness_ids)
-  else:
-    cvs = None
-  lips = make_list(request.user, entry, pos_id, ic, cvs, bl_check)
-  # zakładamy, że symbol == pk
-  return {'lips': lips}
+    if ic_check:
+        ic = InflectionCharacteristic.objects.get(pk=ic_id)
+    else:
+        ic = None
+    if cv_check: # and commonness not in ('undefined', 'None'):
+        cvs = ClassificationValue.objects.filter(pk__in=commonness_ids)
+    else:
+        cvs = None
+    lips = make_list(request.user, entry, pos_id, ic, cvs, bl_check)
+    # zakładamy, że symbol == pk
+    return {'lips': lips}
@@ -7,32 +7,33 @@ from common.util import debug, flatten
 from dictionary.models import CrossReferenceType, ClassificationValue, LexemeAttributeValue
  
 ADJPREDYKATYWNE = [
-  u'ciekaw',
-  u'godzien',
-  u'gotów',
-  u'łaskaw',
-  u'świadom',
-  u'winien',
-  u'zdrów',
-# wątpliwe:
-  u'dłużen',
-  u'miłościw',
-  u'praw',
-  u'wesół',
-  u'żyw',
+    u'ciekaw',
+    u'godzien',
+    u'gotów',
+    u'łaskaw',
+    u'świadom',
+    u'winien',
+    u'zdrów',
+    # wątpliwe:
+    u'dłużen',
+    u'miłościw',
+    u'praw',
+    u'wesół',
+    u'żyw',
 ]
  
 REFL_TRANSLATION = {
-  u'—': 'nonrefl',
-  u'się': 'refl',
-  u'sobie': 'refl',
-  u'się/sobie': 'refl',
-  u'(się)': 'refl.nonrefl',
-  u'(sobie)': 'refl.nonrefl',
+    u'—': 'nonrefl',
+    u'się': 'refl',
+    u'sobie': 'refl',
+    u'się/sobie': 'refl',
+    u'(się)': 'refl.nonrefl',
+    u'(sobie)': 'refl.nonrefl',
 }
  
+
 def qualifier_clause(q_id):
-  return '''not exists (
+    return '''not exists (
     select * from kwalifikatory_leksemow where lexeme_id = l.id and
       qualifier_id = %(q)d) and not exists (
     select * from kwalifikatory_odmieniasiow where qualifier_id = %(q)d and
@@ -40,8 +41,9 @@ def qualifier_clause(q_id):
     select * from kwalifikatory_zakonczen where qualifier_id = %(q)d and
       ending_id = z.id) and ''' % {'q': q_id}
  
+
 def magic_qualifier_clause():
-  return '''and not (tag like %s and exists (
+    return '''and not (tag like %s and exists (
     select kw.id
     from kwalifikatory kw
       join kwalifikatory_leksemow kwl on kw.id = kwl.qualifier_id
@@ -49,45 +51,45 @@ def magic_qualifier_clause():
  
  
 def export_lexemes(data=None, output_file=None):
-  if not data:
-    data = {
-      'vocabs': ['PoliMorf'],
-      'antivocabs': [],
-      'variant': 'Morfeusz',
-      'excluding_qualifiers': [],
-      'magic_qualifiers': [],
-      'refl': False,
-      'commonness': False,
-    }
-  if output_file is None:
-    output_file = sys.stdout
-  vocabs_placeholders = ', '.join('%s' for v in data['vocabs'])
+    if not data:
+        data = {
+            'vocabs': ['PoliMorf'],
+            'antivocabs': [],
+            'variant': 'Morfeusz',
+            'excluding_qualifiers': [],
+            'magic_qualifiers': [],
+            'refl': False,
+            'commonness': False,
+        }
+    if output_file is None:
+        output_file = sys.stdout
+    vocabs_placeholders = ', '.join('%s' for v in data['vocabs'])
  
-  if data['antivocabs']:
-    antivocabs_placeholders = ', '.join('%s' for v in data['antivocabs'])
-    antivocabs_clause = '''not exists (
+    if data['antivocabs']:
+        antivocabs_placeholders = ', '.join('%s' for v in data['antivocabs'])
+        antivocabs_clause = '''not exists (
       select * from leksemy_w_slownikach ls2 where ls2.l_id = l.id
       and ls2.slownik in (%s)) and''' % antivocabs_placeholders
-  else:
-    antivocabs_clause = ''
+    else:
+        antivocabs_clause = ''
  
-  qualifier_clauses = ''.join(
-    qualifier_clause(q_id) for q_id in data['excluding_qualifiers'])
-  magic_qualifier_clauses = ''.join(
-    magic_qualifier_clause() for pattern, q_id in data['magic_qualifiers'])
+    qualifier_clauses = ''.join(
+        qualifier_clause(q_id) for q_id in data['excluding_qualifiers'])
+    magic_qualifier_clauses = ''.join(
+        magic_qualifier_clause() for pattern, q_id in data['magic_qualifiers'])
  
-  crtypes = ['comadv', 'comadj', 'gerver', 'pactver', 'ppasver']
-  crtype_ids = CrossReferenceType.objects.filter(
-    symbol__in=crtypes).values_list('pk', flat=True)
+    crtypes = ['comadv', 'comadj', 'gerver', 'pactver', 'ppasver']
+    crtype_ids = CrossReferenceType.objects.filter(
+        symbol__in=crtypes).values_list('pk', flat=True)
  
-  cv_ids = ClassificationValue.objects.filter(
-    classification__name=u'pospolitość').values_list('pk', flat=True)
+    cv_ids = ClassificationValue.objects.filter(
+        classification__name=u'pospolitość').values_list('pk', flat=True)
  
-  refls = dict(LexemeAttributeValue.objects.filter(
-    attribute__name=u'zwrotność').values_list('pk', 'value'))
+    refls = dict(LexemeAttributeValue.objects.filter(
+        attribute__name=u'zwrotność').values_list('pk', 'value'))
  
-  cursor = connection.cursor()
-  query = """
+    cursor = connection.cursor()
+    query = """
     select distinct haslo, prefiks||rdzen||zak||sufiks, l.pos, ch.charfl, tag,
       l.id as leksem_id, refl.attribute_value_id %(clas_field)s
     from leksemy l
@@ -133,46 +135,46 @@ def export_lexemes(data=None, output_file=None):
       --and g.haslo < 'b'
     order by haslo, leksem_id
     """ % {
-      'vocabs': vocabs_placeholders,
-      'antivocabs': antivocabs_clause,
-      'x_qual': qualifier_clauses,
-      'magic': magic_qualifier_clauses,
-      'crtype_ids': ', '.join(str(pk) for pk in crtype_ids), # brzydko, oj tam
-      'clas_field': ', classification_value_id' if data['commonness'] else '',
-      'clas_join':
-        'left outer join dictionary_lexemecv wkl '
-        'on (wkl.lexeme_id=l.id and wkl.classification_value_id in (%s))'
-        % ', '.join(str(pk) for pk in cv_ids) if data['commonness'] else '',
-      'refl':
-        'refl.attribute_value_id in (%s)'
-        % ', '.join(str(pk) for pk in refls),
+        'vocabs': vocabs_placeholders,
+        'antivocabs': antivocabs_clause,
+        'x_qual': qualifier_clauses,
+        'magic': magic_qualifier_clauses,
+        'crtype_ids': ', '.join(str(pk) for pk in crtype_ids), # brzydko, oj tam
+        'clas_field': ', classification_value_id' if data['commonness'] else '',
+        'clas_join':
+            'left outer join dictionary_lexemecv wkl '
+            'on (wkl.lexeme_id=l.id and wkl.classification_value_id in (%s))'
+            % ', '.join(str(pk) for pk in cv_ids) if data['commonness'] else '',
+        'refl':
+            'refl.attribute_value_id in (%s)'
+            % ', '.join(str(pk) for pk in refls),
     }
-  params_part = (list(data['vocabs']) + list(data['antivocabs']) +
-                 [data['variant']])
-  params = params_part + flatten(data['magic_qualifiers']) + params_part
-  cursor.execute(query, params)
-  refl = data['refl']
-  cv_table = dict(ClassificationValue.objects.values_list('id', 'label'))
-  for row in cursor:
-    if data['commonness']:
-      entry, form, pos, _ic, tag, _id, refl_id, cv_id = row
-    else:
-      entry, form, pos, _ic, tag, _id, refl_id = row
-    form = form.lstrip('+') # odmienne postfiksy
-    if tag == 'adja':
-      form = form.rstrip('+')
-    if tag == 'adjc':
-      if form not in ADJPREDYKATYWNE:
-        tag = "adj:sg:nom:m1.m2.m3:pos|adj:sg:acc:m3:pos"
-    if refl and pos in ('v', 'pact', 'ger'):
-      if refl_id in refls:
-        tag += ':' + REFL_TRANSLATION[refls[refl_id]]
-      else:
-        debug(entry, u'Nieznana zwrotność: %s' % refl_id)
-    if data['commonness']:
-      cv = cv_table[cv_id] if cv_id else ''
-      output_file.write((u'%s\t%s\t%s\t%s\n' %
-                         (form, entry, tag, cv)).encode('utf-8'))
-    else:
-      output_file.write((u'%s\t%s\t%s\n' %
-                         (form, entry, tag)).encode('utf-8'))
+    params_part = (list(data['vocabs']) + list(data['antivocabs']) +
+                   [data['variant']])
+    params = params_part + flatten(data['magic_qualifiers']) + params_part
+    cursor.execute(query, params)
+    refl = data['refl']
+    cv_table = dict(ClassificationValue.objects.values_list('id', 'label'))
+    for row in cursor:
+        if data['commonness']:
+            entry, form, pos, _ic, tag, _id, refl_id, cv_id = row
+        else:
+            entry, form, pos, _ic, tag, _id, refl_id = row
+        form = form.lstrip('+') # odmienne postfiksy
+        if tag == 'adja':
+            form = form.rstrip('+')
+        if tag == 'adjc':
+            if form not in ADJPREDYKATYWNE:
+                tag = "adj:sg:nom:m1.m2.m3:pos|adj:sg:acc:m3:pos"
+        if refl and pos in ('v', 'pact', 'ger'):
+            if refl_id in refls:
+                tag += ':' + REFL_TRANSLATION[refls[refl_id]]
+            else:
+                debug(entry, u'Nieznana zwrotność: %s' % refl_id)
+        if data['commonness']:
+            cv = cv_table[cv_id] if cv_id else ''
+            output_file.write((u'%s\t%s\t%s\t%s\n' %
+                               (form, entry, tag, cv)).encode('utf-8'))
+        else:
+            output_file.write((u'%s\t%s\t%s\n' %
+                               (form, entry, tag)).encode('utf-8'))