Added lemmata filters using semantic frames constrains.

Bartłomiej Nitoń
1 parent a131fa35
Showing 24 changed files with 714 additions and 332 deletions
dictionary/ajax_lemma_view.py
dictionary/common_func.py
dictionary/filtering.py
dictionary/forms.py
dictionary/models.py
dictionary/saving.py
dictionary/static/css/lemmas_filtering.css
dictionary/static/js/lemmas_filtering.js
dictionary/teixml.py
dictionary/templates/filter_form.html
dictionary/templates/lemma_view.html
dictionary/views.py
semantics/change_log.py
semantics/forms.py
semantics/saving.py
semantics/sem_urls.py
semantics/templates/general_preference_form.html
semantics/templates/relational_preference_form.html
semantics/templates/sem_arg_form.html
semantics/templates/synset_preference_form.html
@@ -12,6 +12,7 @@ from django.contrib.auth.models import User, Group
 from django.core import serializers 
 from common.js_to_obj import frameObjToSerializableDict, jsArgToObj, jsFrameToObj, jsPosToObj
+from dictionary.common_func import escape_regex
 from dictionary.convert_frames import frame_conversion
 from dictionary.filtering import default_filter_rules, prepare_filter_form, \
                                  save_lemma_filters_and_get_schemata_filter_setup, \
@@ -29,7 +30,7 @@ from dictionary.models import Vocabulary, Lemma, Lemma_Status, Frame_Opinion, \
                               sortFrameChars, sortArguments, sortPositions, \
                               get_or_create_position, get_schemata_by_type, pos_compatible
 from dictionary.forms import AddPositionForm, FrameForm, Pos_Cat_Form, \
-                             AddNkjpExampleForm, MessageForm, SortForm, FilterForm, \
+                             AddNkjpExampleForm, MessageForm, SortForm, \
                              SimilarLemmasNewForm, ChangeUserFunctionForm, \
                              ExampleOpinionForm, \
                              FrameConversionForm, CreatePositionForm, AssignPhraseologicFrameForm
@@ -39,6 +40,7 @@ from dictionary.saving import connect_example_operation, disconnect_all_examples
 from common.decorators import render, ajax, AjaxError
 from common.util import triple_arg_poss
+from dictionary.filtering import filter_lemmas
 from dictionary.validation import find_similar_frames, get_all_test_missing_frames, get_aspect_rel_lemmas, \
                                   get_wrong_aspect_frames, validate_B_frames, get_deriv_miss_frames_message, \
                                   validate_phraseology_binded_frames, validate_rule_5, \
@@ -46,7 +48,7 @@ from dictionary.validation import find_similar_frames, get_all_test_missing_fram
                                   validate_schemata_for_semantics_and_mark_errors, \
                                   get_missing_aspects_msg, validate_same_positions_schemata
-from semantics.models import LexicalUnitExamples
+from semantics.models import LexicalUnitExamples, SemanticFrame
 from wordnet.models import LexicalUnit
@@ -147,7 +149,7 @@ def prepareFrameTable(frame):
 def nkjpExamplesObjToJs(nkjp_examples, user, lemma):    
   example_dict_list = []
-  lexical_units = lemma.entry_obj.lexical_units()
+  lexical_units = lemma.entry_obj.meanings.all()
   for example in nkjp_examples:
     frame = example.frame;
     frame_table_id = 'frame_'+str(frame.id)+'_'
@@ -168,11 +170,6 @@ def nkjpExamplesObjToJs(nkjp_examples, user, lemma):
     sentence = example.sentence
     comment = example.comment
-#    sentence = example.sentence.replace('\\', '\\\\').replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t").replace("\"", "\\\"")
-#    comment = example.comment.replace('\\', '\\\\').replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t").replace("\"", "\\\"")
-#    h = HTMLParser.HTMLParser()
-#    sentence = h.unescape(sentence)
-#    comment = h.unescape(comment)
     example_dict = { 'example_id'    : example.id,
                      'frame_id'      : frame_table_id,
@@ -423,11 +420,7 @@ def examples_pinned(frame, schema_examples):
 @ajax(method='get')
 def example_got_assigned_semantics(request, lemma_id, example_id):
     lemma = Lemma.objects.get(id=lemma_id) 
-# sprawdz czy najnowsza wersja
-#    if lemma.old:
-#        raise AjaxError('old lemma')
-    # TODO niech lexical units beda wybierane z uzyciem Entry jak juz Tomasz to zrobi
-    lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się'))
+    lexical_units = lemma.entry_obj.meanings.all()
     for lu in lexical_units:
         if LexicalUnitExamples.objects.filter(example__id=example_id,
                                               lexical_unit=lu).exists():
@@ -789,8 +782,7 @@ def get_sort_order(request):
 @render('filter_form.html')
 @ajax(method='get', encode_result=False)
 def filter_form(request):
-    form = prepare_filter_form(request)
-    return {'form': form} 
+    return prepare_filter_form(request) 
 @ajax(method='post')
 def filter_form_submit(request, form_data):
@@ -1355,10 +1347,7 @@ def get_default_char_value(possibilities):
         value = possibilities.get(default=True)  
     except Frame_Char_Value.DoesNotExist:
         value = possibilities.all()[0]
-    return value
-
-def escape_regex(string):
-    return string.replace('(', '\(').replace(')', '\)').replace('{', '\{').replace('}', '\}').replace('[', '\[').replace(']', '\]')   
+    return value   
 def regex_query(string):
     q_query = []
@@ -2336,7 +2325,7 @@ def save_new_frames(request, data, id, examples, lemma_examples):
               reconnect_examples_operations.remove(disconnect_example_operation(example, nkjp_example_obj))
           except ValueError:
               reconnect_examples_operations.append(connect_example_operation(example, nkjp_example_obj))
-    reconnect_examples(reconnect_examples_operations)
+    reconnect_examples(new_lemma_ver, reconnect_examples_operations)
 # dodawanie przykladow nkjp do czasownika
     for example in decoded_lemma_examples:
@@ -2607,90 +2596,6 @@ def prepare_sort_rules(sort_rules):
         prepared_sort_rules.append(rule['name'])
   return prepared_sort_rules
-def pos_regex_frames(frames, string):
-    try:
-        alternative_queries = []
-        for alternative in string.split('|'):
-            possible_frames = frames
-            for conj in alternative.split('&'):
-                model_results = []
-                negation = False
-                conj = conj.strip()
-                if conj.startswith('!'):
-                    conj = conj.lstrip('!')
-                    negation = True
-                regex = ur'^%s$' % escape_regex(conj)
-                model_results = Position.objects.filter(frames__lemmas__old=False,
-                                                        text_rep__regex=regex).distinct()
-                if model_results.exists():
-                    if negation:
-                        possible_frames = possible_frames.exclude(positions__in=model_results)
-                    else:
-                        possible_frames = possible_frames.filter(positions__in=model_results)
-                elif not model_results.exists() and not negation:
-                    possible_frames = Frame.objects.none()
-            alternative_queries.append(Q(id__in=possible_frames))
-        frames = frames.filter(reduce(operator.or_, alternative_queries)).distinct()
-    except:
-        frames = Frame.objects.none()
-    return frames
-
-def arg_regex_frames(frames, string):
-    try:
-        alternative_queries = []
-        for alternative in string.split('|'):
-            possible_frames = frames
-            for conj in alternative.split('&'):
-                model_results = []
-                negation = False
-                conj = conj.strip()
-                if conj.startswith('!'):
-                    conj = conj.lstrip('!')
-                    negation = True
-                regex = ur'^%s$' % escape_regex(conj)
-                model_results = Argument.objects.filter(positions__frames__lemmas__old=False,
-                                                        text_rep__regex=regex).distinct()
-                if model_results.exists():
-                    if negation:
-                        possible_frames = possible_frames.exclude(positions__arguments__in=model_results)
-                    else:
-                        possible_frames = possible_frames.filter(positions__arguments__in=model_results)
-                elif not model_results.exists() and not negation:
-                    possible_frames = Frame.objects.none()
-            alternative_queries.append(Q(id__in=possible_frames))
-        frames = frames.filter(reduce(operator.or_, alternative_queries)).distinct()
-    except:
-        frames = Frame.objects.none()
-    return frames
-
-def lemma_regex_filter(lemmas, string):
-    try:
-        alternative_queries = []
-        for alternative in string.split('|'):
-            possible_lemmas = lemmas
-            for conj in alternative.split('&'):
-                model_results = []
-                negation = False
-                conj = conj.strip()
-                if conj.startswith('!'):
-                    conj = conj.lstrip('!')
-                    negation = True
-                regex = ur'^%s$' % escape_regex(conj)
-                model_results = Lemma.objects.filter(old=False,
-                                                     entry_obj__name__regex=regex).distinct()
-                if model_results.exists():
-                    if negation:
-                        possible_lemmas = possible_lemmas.exclude(pk__in=model_results)
-                    else:
-                        possible_lemmas = possible_lemmas.filter(pk__in=model_results)
-                elif not model_results.exists() and not negation:
-                    possible_lemmas = Lemma.objects.none()
-            alternative_queries.append(Q(id__in=possible_lemmas))
-        lemmas = lemmas.filter(reduce(operator.or_, alternative_queries)).distinct()
-    except:
-        lemmas = Lemma.objects.none()
-    return lemmas
-
 def get_lemma_query(prepared_sort_rules, filter_rules, lemma_query, user):
   lemmas = Lemma.objects.none()
   if user.is_authenticated():
@@ -2711,72 +2616,8 @@ def get_lemma_query(prepared_sort_rules, filter_rules, lemma_query, user):
   lemmas = lemmas.filter(reduce(operator.or_, q_vocab_list))
   lemmas = lemmas.filter(reduce(operator.or_, q_status_list))
-    ## filtrowanie
-  if filter_rules['owner']:
-    lemmas = lemmas.filter(owner=filter_rules['owner'])
-  if filter_rules['phraseologist']:
-    lemmas = lemmas.filter(phraseologist=filter_rules['phraseologist'])
-  if filter_rules['semanticist']:
-    lemmas = lemmas.filter(semanticist=filter_rules['semanticist'])
-  if filter_rules['vocabulary']:
-    lemmas = lemmas.filter(vocabulary=filter_rules['vocabulary'])
-  if filter_rules['status']:
-    lemmas = lemmas.filter(status=filter_rules['status']) 
-  if filter_rules['frame_opinion']:
-    lemmas = lemmas.filter(frame_opinions__value=filter_rules['frame_opinion'])
-  if filter_rules['lemma'] and filter_rules['lemma'] != '.*':
-    lemmas = lemma_regex_filter(lemmas, filter_rules['lemma'])
-  if filter_rules['sender']:
-    lemmas = lemmas.filter(messages__sender=filter_rules['sender'])
-  if filter_rules['pos']:
-    lemmas = lemmas.filter(entry_obj__pos=filter_rules['pos'])
-  if filter_rules['contains_phraseology']:
-      phraseologic_lemmas = lemmas.filter(frames__phraseologic=True)
-      if filter_rules['contains_phraseology'] == 'yes':
-          lemmas = phraseologic_lemmas
-      else:
-          lemmas = lemmas.exclude(pk__in=phraseologic_lemmas)
-  if filter_rules['example_source']:
-    lemmas = lemmas.filter(Q(nkjp_examples__source=filter_rules['example_source']) &
-                           Q(nkjp_examples__approved=False)).distinct()
-    napproved_examples = NKJP_Example.objects.filter(Q(source=filter_rules['example_source']) & 
-                                                     Q(approved=False) &
-                                                     Q(lemmas__old=False) &
-                                                     ~Q(approvers=user)).distinct()
-    
-    if filter_rules['approver']:
-        napproved_examples = napproved_examples.filter(approvers=filter_rules['approver'])
-    lemmas = lemmas.filter(nkjp_examples__in=napproved_examples)
-  lemmas = lemmas.distinct()
- 
-  frames = Frame.objects
-  if filter_rules['reflex']:
-    frames = frames.filter(characteristics=filter_rules['reflex'])
-  if filter_rules['negativity']:
-    frames = frames.filter(characteristics=filter_rules['negativity'])
-  if filter_rules['predicativity']:
-    frames = frames.filter(characteristics=filter_rules['predicativity'])
-  if filter_rules['aspect']:
-    frames = frames.filter(characteristics=filter_rules['aspect'])
-  if filter_rules['position'] and filter_rules['position'] != '.*':
-    frames = pos_regex_frames(frames, filter_rules['position'])
-  if filter_rules['argument'] and filter_rules['argument'] != '.*':
-    frames = arg_regex_frames(frames, filter_rules['argument'])
-  if filter_rules['schema_type']:
-    frames = get_schemata_by_type(filter_rules['schema_type'], frames)
-     
-  if (filter_rules['reflex'] or filter_rules['negativity'] or 
-      filter_rules['aspect'] or filter_rules['predicativity'] or
-      filter_rules['schema_type'] or filter_rules['frame_opinion'] or
-      (filter_rules['argument'] and filter_rules['argument'] != '.*') or
-      (filter_rules['position'] and filter_rules['position'] != '.*')):
-    if filter_rules['frame_opinion']:
-        lemmas = lemmas.filter(frame_opinions__frame__in=frames.all(),
-                               frame_opinions__value=filter_rules['frame_opinion']).distinct()
-    else:
-        lemmas = lemmas.filter(frames__in=frames.all()).distinct()
-    
-  lemmas = lemmas.distinct()
+  ## filtrowanie
+  lemmas = filter_lemmas(lemmas, filter_rules, user)
   ## sortowanie
   entrySortDefined = False
 #-*- coding:utf-8 -*-
-#Copyright (c) 2012, Bartłomiej Nitoń
-#All rights reserved.
-
-#Redistribution and use in source and binary forms, with or without modification, are permitted provided 
-#that the following conditions are met:
-
-#    Redistributions of source code must retain the above copyright notice, this list of conditions and 
-#    the following disclaimer.
-#    Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
-#    and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
-# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-
 '''
 Common functions used in Slowal application.
 '''
@@ -131,4 +111,6 @@ def have_same_positions_structure(pos1, pos2):
     if(pos1_args == pos2_args and pos1_cats==pos2_cats):
         same_structure = True
     return same_structure
-    
+
+def escape_regex(string):
+    return string.replace('(', '\(').replace(')', '\)').replace('{', '\{').replace('}', '\}').replace('[', '\[').replace(']', '\]')
 # -*- coding: utf-8 -*-
+import operator
+
 from django.contrib.auth.models import User
+from django.db.models import Q
 from accounts.models import get_anon_profile
+from dictionary.common_func import escape_regex
 from dictionary.forms import FilterForm
-from dictionary.models import Frame_Char_Model, Frame_Opinion_Value, Lemma_Status, \
-                              NKJP_Source, POS, Vocabulary, \
-                              get_frame_char_and_its_value
+from dictionary.models import Argument, Frame, Frame_Char_Model, Frame_Opinion_Value, \
+                              Lemma, Lemma_Status, NKJP_Example, NKJP_Source, POS, \
+                              Position, Vocabulary, \
+                              get_frame_char_and_its_value, get_schemata_by_type
+from semantics.forms import GeneralSelPrefForm, RelationalSelPrefForm, RoleForm, \
+                            SynsetSelPrefForm
+from semantics.models import Complement, FrameOpinion, RelationalSelectivePreference, \
+                             SemanticFrame
+from wordnet.models import LexicalUnit
 def schemata_filter_options():
     # pobieranie wartosci aspektu
@@ -70,9 +80,11 @@ def default_filter_rules():
             'aspect': None,
             'argument': '.*',
             'position': '.*',
-            'frame_opinion' : None,
+            'schema_opinion' : None,
             'sender': None,
-            'schema_type': None}
+            'schema_type': None,
+            'frame_opinion': None,
+            'sem_arguments': []}
 def prepare_filter_form(request):
     if request.session.has_key('lemma_preview') and request.session['lemma_preview']:
@@ -121,13 +133,60 @@ def prepare_filter_form(request):
                       sel_aspect=filter_rules['aspect'],
                       sel_has_argument=filter_rules['argument'], 
                       sel_has_position=filter_rules['position'],
-                      sel_frame_opinion=filter_rules['frame_opinion'],
+                      sel_schema_opinion=filter_rules['schema_opinion'],
                       can_confirm_example = can_confirm_example,
                       sel_example_source=filter_rules['example_source'],
                       sel_approver=filter_rules['approver'],
                       sel_sender=filter_rules['sender'],
-                      sel_schema_type=filter_rules['schema_type'])
-    return form
+                      sel_schema_type=filter_rules['schema_type'],
+                      sel_frame_opinion=filter_rules['frame_opinion'])
+    return {'form': form,
+            'sem_args_forms': sem_args_to_forms(filter_rules['sem_arguments'])}
+
+def sem_args_to_forms(sem_arguments):
+    args_forms = []
+    first_alternative = True
+    for alternative in sem_arguments:
+        if first_alternative:
+            first_alternative = False
+        else:
+            args_forms.append('or')
+        for arg in alternative:
+            args_forms.append(RoleForm(negation=arg['negation'], 
+                                       sel_role=arg['role'], 
+                                       sel_attribute=arg['attribute'],
+                                       sel_preferences=get_sel_prefs_as_forms(arg)))
+    return args_forms
+
+def get_sel_prefs_as_forms(arg):
+    forms = []
+    if arg['general_prefs']:
+        forms.extend(general_prefs_to_forms(arg['general_prefs']))
+    if arg['synset_prefs']:
+        forms.extend(synset_prefs_to_forms(arg['synset_prefs']))
+    if arg['relational_prefs']:
+        forms.extend(relational_prefs_to_forms(arg['relational_prefs']))
+    return forms
+    
+def general_prefs_to_forms(prefs):
+    forms = []
+    for pref in prefs:
+        forms.append(GeneralSelPrefForm(sel_preference=pref))
+    return forms
+
+def synset_prefs_to_forms(prefs):
+    forms = []
+    for pref in prefs:
+        forms.append(SynsetSelPrefForm(sel_preference=pref))
+    return forms
+
+def relational_prefs_to_forms(prefs):
+    forms = []
+    for pref in prefs:
+        forms.append(RelationalSelPrefForm(sel_relation=pref['relation'], 
+                                           sel_role=pref['role'], 
+                                           sel_attribute=pref['attribute']))
+    return forms
 def save_lemma_filters_and_get_schemata_filter_setup(request, filter_dict):
   if filter_dict['pos']:
@@ -183,17 +242,28 @@ def save_lemma_filters_and_get_schemata_filter_setup(request, filter_dict):
   aspect_obj, aspect_val = get_frame_char_and_its_value(filter_dict['aspect'], '*')
   pred_obj, pred_val = get_frame_char_and_its_value(filter_dict['predicativity'], '*')
-  if filter_dict['frame_opinion']:
-    frame_opinion_obj = Frame_Opinion_Value.objects.get(id=filter_dict['frame_opinion'])
-    opinion_val = frame_opinion_obj.value
+  if filter_dict['schema_opinion']:
+    schema_opinion_obj = Frame_Opinion_Value.objects.get(id=filter_dict['schema_opinion'])
+    opinion_val = schema_opinion_obj.value
   else:
-    frame_opinion_obj = None
+    schema_opinion_obj = None
     opinion_val = '*'
   if 'schema_type' in filter_dict:
       schema_type = filter_dict['schema_type']
   else:
       schema_type = None
+      
+  if filter_dict['frame_opinion']:
+      frame_opinion = FrameOpinion.objects.get(id=filter_dict['frame_opinion'])
+  else:
+      frame_opinion = None
+      
+  if filter_dict['sem_arguments']:
+      sem_arguments = filter_dict['sem_arguments']
+  else:
+      sem_arguments = []
+      
   if request.session.has_key('lemma_preview') and request.session['lemma_preview']:
     request.session['filter_rules_lemma_preview'] = {'pos'                 : pos_obj,
                                                      'contains_phraseology': filter_dict['contains_phraseology'],
@@ -211,9 +281,11 @@ def save_lemma_filters_and_get_schemata_filter_setup(request, filter_dict):
                                                      'argument'            : filter_dict['has_argument'],
                                                      'position'            : filter_dict['has_position'],
                                                      'lemma'               : filter_dict['lemma'],
-                                                     'frame_opinion'       : frame_opinion_obj,
+                                                     'schema_opinion'      : schema_opinion_obj,
                                                      'sender'              : sender_obj,
-                                                     'schema_type'         : schema_type}    
+                                                     'schema_type'         : schema_type,
+                                                     'frame_opinion'       : frame_opinion,
+                                                     'sem_arguments'       : sem_arguments}    
   else:
     request.session['filter_rules'] = {'pos'                 : pos_obj,
                                        'contains_phraseology': filter_dict['contains_phraseology'],
@@ -231,9 +303,11 @@ def save_lemma_filters_and_get_schemata_filter_setup(request, filter_dict):
                                        'argument'            : filter_dict['has_argument'],
                                        'position'            : filter_dict['has_position'],
                                        'lemma'               : filter_dict['lemma'],
-                                       'frame_opinion'       : frame_opinion_obj,
+                                       'schema_opinion'      : schema_opinion_obj,
                                        'sender'              : sender_obj,
-                                       'schema_type'         : schema_type}
+                                       'schema_type'         : schema_type,
+                                       'frame_opinion'       : frame_opinion,
+                                       'sem_arguments'       : sem_arguments}
   return {'filter_frames': filter_dict['filter_frames'],
           'schema_type'  : schema_type,
@@ -244,3 +318,242 @@ def save_lemma_filters_and_get_schemata_filter_setup(request, filter_dict):
           'aspect'       : aspect_val,
           'position'     : filter_dict['has_position'],
           'argument'     : filter_dict['has_argument']}
+
+def filter_lemmas(lemmas, filter_rules, user):
+    lemmas = filter_by_lemma_properties(lemmas, filter_rules, user)
+    lemmas = filter_by_schemata(lemmas, filter_rules)
+    lemmas = filter_by_frames(lemmas, filter_rules)  
+    return lemmas
+  
+def filter_by_lemma_properties(lemmas, filter_rules, user):
+    if filter_rules['owner']:
+        lemmas = lemmas.filter(owner=filter_rules['owner'])
+    if filter_rules['phraseologist']:
+        lemmas = lemmas.filter(phraseologist=filter_rules['phraseologist'])
+    if filter_rules['semanticist']:
+        lemmas = lemmas.filter(semanticist=filter_rules['semanticist'])
+    if filter_rules['vocabulary']:
+        lemmas = lemmas.filter(vocabulary=filter_rules['vocabulary'])
+    if filter_rules['status']:
+        lemmas = lemmas.filter(status=filter_rules['status']) 
+    if filter_rules['schema_opinion']:
+        lemmas = lemmas.filter(frame_opinions__value=filter_rules['schema_opinion'])
+    if filter_rules['lemma'] and filter_rules['lemma'] != '.*':
+        lemmas = lemma_regex_filter(lemmas, filter_rules['lemma'])
+    if filter_rules['sender']:
+        lemmas = lemmas.filter(messages__sender=filter_rules['sender'])
+    if filter_rules['pos']:
+        lemmas = lemmas.filter(entry_obj__pos=filter_rules['pos'])
+    if filter_rules['contains_phraseology']:
+        phraseologic_lemmas = lemmas.filter(frames__phraseologic=True)
+        if filter_rules['contains_phraseology'] == 'yes':
+            lemmas = phraseologic_lemmas
+        else:
+            lemmas = lemmas.exclude(pk__in=phraseologic_lemmas)
+    if filter_rules['example_source']:
+        lemmas = lemmas.filter(Q(nkjp_examples__source=filter_rules['example_source']) &
+                               Q(nkjp_examples__approved=False)).distinct()
+        napproved_examples = NKJP_Example.objects.filter(Q(source=filter_rules['example_source']) & 
+                                                         Q(approved=False) &
+                                                         Q(lemmas__old=False) &
+                                                         ~Q(approvers=user)).distinct()
+    
+        if filter_rules['approver']:
+            napproved_examples = napproved_examples.filter(approvers=filter_rules['approver'])
+        lemmas = lemmas.filter(nkjp_examples__in=napproved_examples)
+    lemmas = lemmas.distinct()
+    return lemmas
+
+def lemma_regex_filter(lemmas, string):
+    try:
+        alternative_queries = []
+        for alternative in string.split('|'):
+            possible_lemmas = lemmas
+            for conj in alternative.split('&'):
+                model_results = []
+                negation = False
+                conj = conj.strip()
+                if conj.startswith('!'):
+                    conj = conj.lstrip('!')
+                    negation = True
+                regex = ur'^%s$' % escape_regex(conj)
+                model_results = Lemma.objects.filter(old=False,
+                                                     entry_obj__name__regex=regex).distinct()
+                if model_results.exists():
+                    if negation:
+                        possible_lemmas = possible_lemmas.exclude(pk__in=model_results)
+                    else:
+                        possible_lemmas = possible_lemmas.filter(pk__in=model_results)
+                elif not model_results.exists() and not negation:
+                    possible_lemmas = Lemma.objects.none()
+            alternative_queries.append(Q(id__in=possible_lemmas))
+        lemmas = lemmas.filter(reduce(operator.or_, alternative_queries)).distinct()
+    except:
+        lemmas = Lemma.objects.none()
+    return lemmas
+
+def filter_by_schemata(lemmas, filter_rules):
+    schemata = Frame.objects
+    if filter_rules['reflex']:
+        schemata = schemata.filter(characteristics=filter_rules['reflex'])
+    if filter_rules['negativity']:
+        schemata = schemata.filter(characteristics=filter_rules['negativity'])
+    if filter_rules['predicativity']:
+        schemata = schemata.filter(characteristics=filter_rules['predicativity'])
+    if filter_rules['aspect']:
+        schemata = schemata.filter(characteristics=filter_rules['aspect'])
+    if filter_rules['position'] and filter_rules['position'] != '.*':
+        schemata = pos_regex_frames(schemata, filter_rules['position'])
+    if filter_rules['argument'] and filter_rules['argument'] != '.*':
+        schemata = arg_regex_frames(schemata, filter_rules['argument'])
+    if filter_rules['schema_type']:
+        schemata = get_schemata_by_type(filter_rules['schema_type'], schemata)
+       
+    if (filter_rules['reflex'] or filter_rules['negativity'] or 
+        filter_rules['aspect'] or filter_rules['predicativity'] or
+        filter_rules['schema_type'] or filter_rules['schema_opinion'] or
+        (filter_rules['argument'] and filter_rules['argument'] != '.*') or
+        (filter_rules['position'] and filter_rules['position'] != '.*')):
+        if filter_rules['schema_opinion']:
+            lemmas = lemmas.filter(frame_opinions__frame__in=schemata.all(),
+                                   frame_opinions__value=filter_rules['schema_opinion'])
+        else:
+            lemmas = lemmas.filter(frames__in=schemata.all()) 
+    lemmas = lemmas.distinct()
+    return lemmas
+
+def pos_regex_frames(frames, string):
+    try:
+        alternative_queries = []
+        for alternative in string.split('|'):
+            possible_frames = frames
+            for conj in alternative.split('&'):
+                model_results = []
+                negation = False
+                conj = conj.strip()
+                if conj.startswith('!'):
+                    conj = conj.lstrip('!')
+                    negation = True
+                regex = ur'^%s$' % escape_regex(conj)
+                model_results = Position.objects.filter(frames__lemmas__old=False,
+                                                        text_rep__regex=regex).distinct()
+                if model_results.exists():
+                    if negation:
+                        possible_frames = possible_frames.exclude(positions__in=model_results)
+                    else:
+                        possible_frames = possible_frames.filter(positions__in=model_results)
+                elif not model_results.exists() and not negation:
+                    possible_frames = Frame.objects.none()
+            alternative_queries.append(Q(id__in=possible_frames))
+        frames = frames.filter(reduce(operator.or_, alternative_queries)).distinct()
+    except:
+        frames = Frame.objects.none()
+    return frames
+
+def arg_regex_frames(frames, string):
+    try:
+        alternative_queries = []
+        for alternative in string.split('|'):
+            possible_frames = frames
+            for conj in alternative.split('&'):
+                model_results = []
+                negation = False
+                conj = conj.strip()
+                if conj.startswith('!'):
+                    conj = conj.lstrip('!')
+                    negation = True
+                regex = ur'^%s$' % escape_regex(conj)
+                model_results = Argument.objects.filter(positions__frames__lemmas__old=False,
+                                                        text_rep__regex=regex).distinct()
+                if model_results.exists():
+                    if negation:
+                        possible_frames = possible_frames.exclude(positions__arguments__in=model_results)
+                    else:
+                        possible_frames = possible_frames.filter(positions__arguments__in=model_results)
+                elif not model_results.exists() and not negation:
+                    possible_frames = Frame.objects.none()
+            alternative_queries.append(Q(id__in=possible_frames))
+        frames = frames.filter(reduce(operator.or_, alternative_queries)).distinct()
+    except:
+        frames = Frame.objects.none()
+    return frames
+
+def filter_by_frames(lemmas, filter_rules):
+    frames = SemanticFrame.objects.filter(next__isnull=True, removed=False)
+    if filter_rules['frame_opinion']:
+        frames = frames.filter(opinion=filter_rules['frame_opinion'])
+    if filter_rules['sem_arguments']:
+        frames = get_frames_by_args_rule(frames, filter_rules['sem_arguments'])
+    if filter_rules['frame_opinion'] or filter_rules['sem_arguments']:
+        lemmas = lemmas.filter(entry_obj__meanings__frames__in=frames).distinct()
+    return lemmas
+
+def get_frames_by_args_rule(frames, args_filter_rule):
+    matching_frames = []
+    for alternative in args_filter_rule:
+        alt_matching_frames = get_matching_frames(frames, alternative)
+        matching_frames.extend(alt_matching_frames.values_list('id', flat=True))
+    return frames.filter(id__in=list(set(matching_frames)))
+
+def get_matching_frames(frames, arguments_rules):
+    for rules in arguments_rules:
+        if not rules['negation']:
+            frames = frames.filter(complements__in=matching_complements(rules))
+        else:
+            frames = frames.exclude(complements__in=matching_complements(rules))
+    return frames
+        
+def matching_complements(filter_rules):
+    complements = Complement.objects
+    if filter_rules['role']:
+        complements = complements.filter(roles=filter_rules['role'])
+    if filter_rules['attribute']:
+        complements = complements.filter(roles=filter_rules['attribute'])
+    if filter_rules['general_prefs'] or filter_rules['synset_prefs'] or filter_rules['relational_prefs']:
+        complements = complements.filter(selective_preference__isnull=False)
+    if filter_rules['general_prefs']:
+        complements = filter_by_general_prefs(complements, filter_rules['general_prefs'])
+    if filter_rules['synset_prefs']:
+        complements = filter_by_synset_prefs(complements, filter_rules['synset_prefs'])
+    if filter_rules['relational_prefs']:
+        complements = filter_by_relational_prefs(complements, filter_rules['relational_prefs'])
+    return complements.all()
+
+def filter_by_general_prefs(complements, prefs):
+    complements = complements.exclude(selective_preference__generals=None)
+    for pref in list(set(prefs)):
+        if pref:
+            complements = complements.filter(selective_preference__generals=pref)
+    return complements
+
+def filter_by_synset_prefs(complements, prefs):
+    complements = complements.exclude(selective_preference__synsets=None)
+    for pref in list(set(prefs)):
+        if pref:
+            try:
+                pref_parts = pref.split('-')
+                base = pref_parts[0]
+                sense = pref_parts[1]
+                synset = LexicalUnit.objects.get(base=base, sense=sense).synset
+                complements = complements.filter(selective_preference__synsets=synset)
+            except:
+                complements = Complement.objects.none()
+    return complements
+
+def filter_by_relational_prefs(complements, prefs):
+    complements = complements.exclude(selective_preference__relations=None)
+    for pref in prefs:
+        if pref['relation'] or pref['role'] or pref['attribute']:
+            relational_prefs = RelationalSelectivePreference.objects
+            if pref['relation']:
+                relational_prefs = relational_prefs.filter(relation=pref['relation'])
+            if pref['role'] or pref['attribute']:
+                to_complements = Complement.objects
+                if pref['role']:
+                    to_complements = to_complements.filter(roles=pref['role'])
+                if pref['attribute']:
+                    to_complements = to_complements.filter(roles=pref['attribute'])
+                relational_prefs = relational_prefs.filter(to__in=to_complements.all()).distinct()
+            complements = complements.filter(selective_preference__relations__in=relational_prefs).distinct()
+    return complements
+    
 \ No newline at end of file
 #-*- coding:utf-8 -*-
-#Copyright (c) 2012, Bartłomiej Nitoń
-#All rights reserved.
-
-#Redistribution and use in source and binary forms, with or without modification, are permitted provided 
-#that the following conditions are met:
-
-#    Redistributions of source code must retain the above copyright notice, this list of conditions and 
-#    the following disclaimer.
-#    Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
-#    and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
-# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-
 import datetime
 from django.contrib.auth.forms import UserCreationForm
@@ -28,6 +8,7 @@ from django.db.models import Q
 from django.forms import *
 from dictionary.models import *
+from semantics.models import FrameOpinion
 #Frame, Argument_Model, AttrValueSelectionMode, \
 #                              AttrValuesSeparator, Atribute_Value, PositionCategory, \
 #                              Argument, Atribute_Model, ArgRealOpinion, Frame_Characteristic, \
@@ -530,11 +511,6 @@ class MessageForm(ModelForm):
 ############################ sorting, filtering
-
-#trzeba dodac jeszcze opcje, ze zawiera tylko normalne hasla
-#no i filtrowanie po lematach z wykorzystaniem wyrazen regularnych
-# rozbić to wszystko na 3 zakładki Hasło, Schematy, Ramy
-# no i oczywiście dodać te pola do filtrowania schematów
 class FilterForm(Form):
   # Lemma filters
@@ -571,14 +547,13 @@ class FilterForm(Form):
                             required=False)
   has_argument = forms.CharField(label=u'Zawiera typ frazy', required=False)
   has_position = forms.CharField(label=u'Zawiera pozycję', required=False) 
-  frame_opinion = ModelChoiceField(label=u'Opinia o schemacie', queryset=Frame_Opinion_Value.objects.all(), 
-                                   required=False)
+  schema_opinion = ModelChoiceField(label=u'Opinia o schemacie', queryset=Frame_Opinion_Value.objects.all(), 
+                                    required=False)
   filter_frames = forms.BooleanField(label=u'Odfiltruj niepasujące schematy', initial=False,
                                      required=False)
   # Frame filters
-#  role = 
-#  selective_preferences = 
-#  opinion = 
+  frame_opinion = ModelChoiceField(label=u'Opinia o ramie', queryset=FrameOpinion.objects.order_by('priority'), 
+                                   required=False)
   def __init__(self, users, phraseologists, semanticists, vocabularies, statuses, senders,
                lemma='.*', sel_pos=None, contains_phraseology=None, 
@@ -586,8 +561,9 @@ class FilterForm(Form):
                sel_vocabulary=None, sel_status=None, sel_schema_type=None,
                sel_reflex=None, sel_negativity=None, sel_predicativity=None, 
                sel_aspect=None, sel_has_argument='.*', sel_has_position='.*',
-               sel_frame_opinion=None, can_confirm_example=False, sel_example_source=None, 
-               sel_approver=None, sel_sender=None, *args, **kwargs):
+               sel_schema_opinion=None, can_confirm_example=False, sel_example_source=None, 
+               sel_approver=None, sel_sender=None, 
+               sel_frame_opinion=None, *args, **kwargs):
     super(FilterForm, self).__init__(*args, **kwargs)
     self.fields['pos'].queryset = POS.objects.exclude(tag='unk')
@@ -612,23 +588,20 @@ class FilterForm(Form):
       self.fields['example_source'].initial = None
       self.fields['approver'].widget = self.fields['approver'].hidden_widget()
       self.fields['approver'].initial = None
-#    self.fields['has_old_frames_property'].initial = sel_old_property
     self.fields['reflex'].initial = sel_reflex
     self.fields['negativity'].initial = sel_negativity
     self.fields['predicativity'].initial = sel_predicativity
     self.fields['aspect'].initial = sel_aspect
     self.fields['has_argument'].initial = sel_has_argument
     self.fields['has_position'].initial = sel_has_position
-    #self.fields['has_frame'].initial = sel_has_frame
-    self.fields['frame_opinion'].initial = sel_frame_opinion
+    self.fields['schema_opinion'].initial = sel_schema_opinion
     self.fields['has_message_from'].initial = sel_sender
     self.fields['has_message_from'].queryset = senders
     self.fields['schema_type'].initial = sel_schema_type
+    self.fields['frame_opinion'].initial = sel_frame_opinion
     self.hide_unused_fields()
-
-    #self.fields['has_frame'].widget = self.fields['has_frame'].hidden_widget()
   def hide_unused_fields(self):
     for field_name in self.fields:
 #-*- coding:utf-8 -*-
-#Copyright (c) 2012, Bartłomiej Nitoń
-#All rights reserved.
-
-#Redistribution and use in source and binary forms, with or without modification, are permitted provided 
-#that the following conditions are met:
-
-#    Redistributions of source code must retain the above copyright notice, this list of conditions and 
-#    the following disclaimer.
-#    Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
-#    and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
-# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-
 from django.contrib.auth.models import User
 from django.db.models import * 
-from wordnet.models import LexicalUnit
-
 class Configuration(Model):
     name = CharField(max_length=16, primary_key=True, unique=True, db_column='nazwa_konfiguracji')
     selected_conf = BooleanField(db_column='wybrana_konfiguracja', default=False)
@@ -766,13 +744,6 @@ class Argument(Model):
                     break
         return is_fully_lexicalized
-    class Meta:
-      permissions = (
-        ('view_realization', u'Może oglądać realizacje argumentów.'),
-        ('create_realization', u'Może kreować realizacje argumentów.'),
-        ('view_arg_stats', u'Może oglądać statystyki argumentów.'),
-      )
-
     def __unicode__(self):
         return '%s' % (self.text_rep)
@@ -785,7 +756,21 @@ class Argument(Model):
             for value in attr.values.filter(type__sym_name=u'parameter'):
                 if value.parameter.type.realization_only:
                     return True
-        return False        
+        return False
+    
+    def main_phrase_type(self):
+        category_attrs = self.atributes.filter(type=u'KATEGORIA')
+        if not category_attrs.exists() or category_attrs.all()[0].values.count() == 0: # xp bez podtypow
+            return self
+        else:
+            return Argument.objects.get(text_rep=u'%s(%s)' % (self.type, category_attrs.all()[0].selection_mode.name))
+    
+    class Meta:
+      permissions = (
+        ('view_realization', u'Może oglądać realizacje argumentów.'),
+        ('create_realization', u'Może kreować realizacje argumentów.'),
+        ('view_arg_stats', u'Może oglądać statystyki argumentów.'),
+      ) 
 def sort_arguments(arguments):
     return sortArguments(arguments)
@@ -1403,12 +1388,9 @@ class Entry(Model):
             ('view_semantics', u'Może oglądać semantykę.'),
         )
-    def lexical_units(self):
-        return LexicalUnit.objects.filter(Q(base = self.name)|Q(base = self.name + u' się'))
-    
     def actual_frames(self):
         frame_ids = []
-        lexical_units = self.lexical_units().order_by('sense')
+        lexical_units = self.meanings.order_by('sense')
         for lexical_unit in lexical_units:
             frame_ids.extend([f.id for f in lexical_unit.actual_frames()])
         return get_model('semantics', 'SemanticFrame').objects.filter(id__in=list(set(frame_ids)))
@@ -94,7 +94,7 @@ def update_connections(lemma_id, reconnect_operations, user):
 def disconnect_all_examples_operations(lemma):
     operations = []
-    lex_units = lemma.entry_obj.lexical_units().all()
+    lex_units = lemma.entry_obj.meanings.all()
     for lu in lex_units:
         lu_examples = LexicalUnitExamples.objects.filter(lexical_unit=lu)
         for lu_ex in lu_examples:
@@ -112,6 +112,6 @@ def disconnect_example_operation(example_dict, example_obj):
     lu = LexicalUnit.objects.get(id=example_dict['lexical_unit'])
     return {'operation': 'remove_example', 'unit': lu.id, 'example': example_obj.id}
-def reconnect_examples(operations):
-    update_meanings(operations)
+def reconnect_examples(lemma, operations):
+    update_meanings(lemma.id, operations)
 \ No newline at end of file
+hr.filtersSeparator {
+	border-top: medium double #333;
+}
+
+hr.argSeparator {
+	border-top: 1px dashed #8c8b8b;
+}
+
+hr.alterSeparator {
+    border-top: 1px solid #8c8b8b;
+}
@@ -3,15 +3,74 @@ function filter_form_submit() {
     form_data = this_form.serializeArray();
     var filter_frames = false;
+    var actSemArgument = {};
+    var relationalSemPref = {'relation': '',
+    						 'role': '',
+    						 'attribute': ''};
+    var semArgumentsAlternatives = [];
+    var semArguments = [];
     form_data = $.map(form_data, function(elem)
     {
-      if (elem.name != 'filter_frames') return elem;
+      if (elem.name != 'filter_frames' && !isPartOfSemArgFilter(elem)) {
+    	  return elem;
+      }
       else {
-    	  if (elem.name == 'filter_frames') filter_frames = elem.value;
+    	  if(elem.name == 'filter_frames') {
+    		  filter_frames = elem.value;
+    	  }
+    	  else if(elem.name == 'negation') {
+    		  if(!jQuery.isEmptyObject(actSemArgument)) {
+    			  semArguments.push(actSemArgument);
+    		  }
+    		  actSemArgument = {'negation': elem.value,
+				  	  			'role': '',
+				  	  			'attribute': '',
+				  	  			'general_prefs': [],
+				  	  			'synset_prefs': [],
+				  	  			'relational_prefs': []}
+    	  }
+    	  else if(elem.name == 'or') {
+    		  if(!jQuery.isEmptyObject(actSemArgument)) {
+    			  semArguments.push(actSemArgument);
+    			  actSemArgument = {};
+    		  }
+    		  semArgumentsAlternatives.push(semArguments);
+    		  semArguments = [];
+    	  } 
+    	  else if(elem.name == 'role' || elem.name == 'attribute') {
+    		  actSemArgument[elem.name] = elem.value;
+    	  }
+    	  else if(elem.name == 'general_pref' || elem.name == 'synset_pref') {
+    		  actSemArgument[elem.name+'s'].push(elem.value);
+    	  }
+    	  else if(elem.name.startsWith('relational_pref')) {
+    		  if(elem.name.endsWith('relation')) {
+    			  relationalSemPref = {'relation': elem.value,
+ 						 			   'role': '',
+ 						               'attribute': ''};
+    		  }
+    		  else if(elem.name.endsWith('role')) {
+    			  relationalSemPref['role'] = elem.value;
+    		  }
+    		  else if(elem.name.endsWith('attribute')) {
+    			  relationalSemPref['attribute'] = elem.value;
+    			  actSemArgument['relational_prefs'].push(relationalSemPref);
+    			  relationalSemPref = {};
+    		  }
+    	  }
       }
     });
+    if(!jQuery.isEmptyObject(actSemArgument)) {
+		  semArguments.push(actSemArgument);
+	}
+    if(semArguments.length > 0) {
+    	semArgumentsAlternatives.push(semArguments);
+    }
+	
+    
     form_data.push({name: 'filter_frames', value: filter_frames});
+    form_data.push({name: 'sem_arguments', value: semArgumentsAlternatives});
     act_lemma_id = window.prev_lemma_id;
     if(window.activeLemmaPanel != 'preview_lemma')
@@ -82,3 +141,51 @@ function filter_form_submit() {
   });
   return false;
 }
+
+function isPartOfSemArgFilter(field) {
+	if(field.name == 'or' || field.name == 'negation' || 
+	   field.name == 'role' || field.name == 'attribute' || 
+	   field.name == 'general_pref' || field.name == 'synset_pref' || 
+	   field.name.startsWith('relational_pref')) {
+		return true;
+	}
+	return false;
+}
+
+function addSemArgFilter(buttonElem) {
+	var semArgsElem = $(buttonElem).parent().parent();
+	semArgsElem.append('<p id="sem-argument"></p>');
+	semArgsElem.children().last().load(ajax_sem_arg_form);
+}
+
+function addArgAlternative(buttonElem) {
+	var semArgsElem = $(buttonElem).parent().parent();
+	semArgsElem.append('<div><hr class="alterSeparator"><input type="hidden" name="or" value="or"><strong>lub</strong> <button type="button" onclick="removeAlternative(this)">Usuń</button></div>');
+}
+
+function removeAlternative(buttonElem) {
+	$(buttonElem).parent().remove();
+}
+
+function removeSemArgFilter(buttonElem) {
+	$(buttonElem).parent().parent().remove();
+}
+
+function addSelectivePreferenceFilter(buttonElem) {
+	var selPrefsElem = $(buttonElem).parent().parent();
+	var selPrefType = selPrefsElem.find('#id_preference_type').first().val();
+	selPrefsElem.append('<p id="sel-preference"></p>');
+	if(selPrefType === 'general') {
+		selPrefsElem.children().last().load(ajax_general_preference_form);
+	}
+	else if(selPrefType === 'synset') {
+		selPrefsElem.children().last().load(ajax_synset_preference_form);
+	}
+	else if(selPrefType === 'relation') {
+		selPrefsElem.children().last().load(ajax_relational_preference_form);
+	}
+}
+
+function removeSelPreferenceFilter(buttonElem) {
+	$(buttonElem).parent().remove();
+}
@@ -437,7 +437,7 @@ def write_example(parent_elem, lemma, example):
 def get_and_write_meaning_link(parent_elem, entry, example):
     try:
-        entry_lex_units = entry.lexical_units()
+        entry_lex_units = entry.meanings.all()
         lex_unit_example = LexicalUnitExamples.objects.get(example=example,
                                                            lexical_unit__in=entry_lex_units)
         meaning = lex_unit_example.lexical_unit
@@ -674,8 +674,7 @@ def write_meanings_layer(parent_elem, lemma):
 def write_meanings(parent_elem, lemma):
     entry = lemma.entry_obj
-    lex_units = entry.lexical_units()
-    for lex_unit in lex_units.all():
+    for lex_unit in entry.meanings.all():
         write_meaning(parent_elem, entry, lex_unit)
 def write_meaning(parent_elem, entry, lex_unit):
@@ -47,6 +47,7 @@ $(function(){
     <ul>
        <li><a href="#lemma-filters">Hasło</a></li>
        <li><a href="#schema-filters">Schematy</a></li>
+       <li><a href="#frame-filters">Ramy</a></li>
     </ul>
     <div id="lemma-filters">
       {% if not form.lemma.is_hidden %}
@@ -68,7 +69,7 @@ $(function(){
         </p>
       {% endif %}
       {% if not form.owner.is_hidden or not form.phraseologist.is_hidden or not form.semanticist.is_hidden %}
-        <hr>
+        <hr class="filtersSeparator">
       {% endif %}
       {% if not form.owner.is_hidden %}
         <p class="fieldWrapper">
@@ -89,7 +90,7 @@ $(function(){
         </p>
       {% endif %}
       {% if not form.vocabulary.is_hidden or not form.status.is_hidden or not form.has_message_from.is_hidden %}
-        <hr>
+        <hr class="filtersSeparator">
       {% endif %}
       {% if not form.vocabulary.is_hidden %}
         <p class="fieldWrapper">
@@ -110,7 +111,7 @@ $(function(){
         </p>
       {% endif %}
       {% if not form.example_source.is_hidden or not form.approver.is_hidden %}
-        <hr>
+        <hr class="filtersSeparator">
       {% endif %}
       {% if not form.example_source.is_hidden %}
         <p class="fieldWrapper">
@@ -126,10 +127,10 @@ $(function(){
       {% endif %}
 	</div>
 	<div id="schema-filters">
-	  {% if not form.frame_opinion.is_hidden %}
+	  {% if not form.schema_opinion.is_hidden %}
         <p class="fieldWrapper">
-          {{ form.frame_opinion.errors }}
-          {{ form.frame_opinion.label_tag }}: {{ form.frame_opinion }}
+          {{ form.schema_opinion.errors }}
+          {{ form.schema_opinion.label_tag }}: {{ form.schema_opinion }}
         </p>
       {% endif %}
 	  {% if not form.schema_type.is_hidden %}
@@ -181,6 +182,26 @@ $(function(){
         </p>
       {% endif %}
 	</div>
+	<div id="frame-filters">
+      {% if not form.frame_opinion.is_hidden %}
+        <p class="fieldWrapper">
+          {{ form.frame_opinion.errors }}
+          {{ form.frame_opinion.label_tag }}: {{ form.frame_opinion }}
+        </p>
+      {% endif %}
+      <hr class="filtersSeparator">
+      <div id="sem-arguments">
+        <p>Argumenty semantyczne: 
+          <button type="button" onclick="addSemArgFilter(this)">Dodaj</button>
+          <button type="button" onclick="addArgAlternative(this)">Lub</button>
+        </p>
+		{% for arg_form in sem_args_forms %}
+		  <div id="sem-argument">
+		    {% include 'sem_arg_form.html' with form=arg_form only %}
+		  </div>
+		{% endfor %}
+      </div>
+	</div>
   </div>
   {% for hidden in form.hidden_fields %}
     {{ hidden }}
@@ -9,6 +9,7 @@
   <link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/examples_table.css"/>
   <link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/aspect_relations_table.css"/>
   <link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/filter_frames_menu.css"/>
+  <link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/lemmas_filtering.css"/>
   <script type="text/javascript" src="{{ STATIC_URL }}js/lib/grid.locale-pl.js"></script>
   <script type="text/javascript">
     jQuery.jgrid.no_legacy_api = true;
@@ -62,9 +63,7 @@
       <ul>
         <li id="refresh_frames"><a href="#new_frames">{% trans "Schematy" %} [<span id="new-frames-count"></span>]</a></li>
-        {% if perms.dictionary.view_semantics %}
-          <li><a href="#semantics">{% trans "Semantyka" %} [<span id="semantic-frames-count"></span>]</a></li>
-        {% endif %}
+        <li><a href="#semantics">{% trans "Semantyka" %} [<span id="semantic-frames-count"></span>]</a></li>
         <!-- li><a href="#old_frames">{% trans "Stare schematy" %}</a></li -->
         {% if perms.dictionary.add_notes %}
         	<li><a href="#notes">{% trans "Notatki" %} [<span id="lemma-notes-count"></span>]</a></li>
@@ -81,10 +80,8 @@
       </ul>
       <div id="new_frames">
       </div>
-      {% if perms.dictionary.view_semantics %}
-          <div id="semantics">
-          </div>
-      {% endif %}
+      <div id="semantics">
+      </div>
       {% if perms.dictionary.add_notes %}
 	      <div id="notes">
 	      </div>
 #-*- coding:utf-8 -*-
-#Copyright (c) 2012, Bartłomiej Nitoń
-#All rights reserved.
-
-#Redistribution and use in source and binary forms, with or without modification, are permitted provided 
-#that the following conditions are met:
-
-#    Redistributions of source code must retain the above copyright notice, this list of conditions and 
-#    the following disclaimer.
-#    Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
-#    and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
-# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-
 import datetime
 import os
@@ -212,6 +192,11 @@ def lemma_view(request):
     'ajax_save_columns': reverse('save_columns'),
     'ajax_save_columns': reverse('save_columns'),
     'ajax_get_sort_order': reverse('get_sort_order'),
+    'ajax_sem_arg_form': reverse('sem_arg_form'),
+    'ajax_general_preference_form': reverse('general_preference_form'),
+    'ajax_synset_preference_form': reverse('synset_preference_form'),
+    'ajax_relational_preference_form': reverse('relational_preference_form'),
+    'ajax_synset_context_lookup': reverse('synset_context_lookup'),
  # czasowniki podobne
     'ajax_similar_lemmas_old_form_submit': reverse('similar_lemmas_old_form_submit'),
@@ -179,7 +179,7 @@ def backup_lemma_and_get_frames(lemma):
 def backup_lemma(lemma_id):
     lemma = Lemma.objects.get(id=lemma_id, old=False)
-    lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się')).order_by('sense')
+    lexical_units = lemma.entry_obj.meanings.order_by('sense')
     frame_ids = []
     for lexical_unit in lexical_units:
+#-*- coding:utf-8 -*-
+
+from django.forms import CharField, ChoiceField, Form, ModelChoiceField
+
+from semantics.models import GeneralSelectivePreference, SelectivePreferenceRelations, SemanticRole
+
+class RoleForm(Form):
+    negation = ChoiceField(choices=[('', u'---'), ('!', u'!')], required=False,
+                                    label=u'')
+    role = ModelChoiceField(label=u'Rola', required=False,
+                            queryset=SemanticRole.objects.filter(gradient__isnull=True))
+    attribute = ModelChoiceField(label=u'Atrybut', required=False,
+                               queryset=SemanticRole.objects.filter(gradient__isnull=False))
+    preference_type = ChoiceField(choices=[('general', u'Predefiniowana'), ('synset', u'Słowosieć'), ('relation', u'Relacja')], 
+                                  label=u'Preferencje selekcyjne', required=False)
+    preferences = []
+  
+    def __init__(self, negation=None, sel_role=None, sel_attribute=None,
+                  sel_preferences=[], 
+                  *args, **kwargs):
+        super(RoleForm, self).__init__(*args, **kwargs)
+        self.fields['negation'].initial = negation
+        self.fields['role'].initial = sel_role
+        self.fields['attribute'].initial = sel_attribute
+        self.preferences = sel_preferences
+        
+class GeneralSelPrefForm(Form):
+    general_pref = ModelChoiceField(label=u'Predefiniowana', 
+                                    queryset=GeneralSelectivePreference.objects.order_by('name'), required=False)
+    
+    def pref_type(self):
+        return 'general'
+  
+    def __init__(self, sel_preference=None, *args, **kwargs):
+        super(GeneralSelPrefForm, self).__init__(*args, **kwargs)
+        self.fields['general_pref'].initial = sel_preference
+
+class SynsetSelPrefForm(Form):
+    synset_pref = CharField(label=u'Słowosieć', required=False)
+    
+    def pref_type(self):
+        return 'synset'
+  
+    def __init__(self, sel_preference=None, *args, **kwargs):
+        super(SynsetSelPrefForm, self).__init__(*args, **kwargs)
+        self.fields['synset_pref'].initial = sel_preference
+        
+class RelationalSelPrefForm(Form):
+    relational_pref_relation = ModelChoiceField(label=u'Relacja', 
+                                queryset=SelectivePreferenceRelations.objects.all(), required=False)
+    relational_pref_role = ModelChoiceField(label=u'Rola', required=False,
+                            queryset=SemanticRole.objects.filter(gradient__isnull=True))
+    relational_pref_attribute = ModelChoiceField(label=u'Atrybut', required=False,
+                               queryset=SemanticRole.objects.filter(gradient__isnull=False))
+  
+    def pref_type(self):
+        return 'relational'
+        
+    def __init__(self, sel_relation=None, sel_role=None, sel_attribute=None, *args, **kwargs):
+        super(RelationalSelPrefForm, self).__init__(*args, **kwargs)
+        self.fields['relational_pref_relation'].initial = sel_relation
+        self.fields['relational_pref_role'].initial = sel_role
+        self.fields['relational_pref_attribute'].initial = sel_attribute
+    
 \ No newline at end of file
@@ -2,7 +2,7 @@
 from django.db.models import Min
-from dictionary.models import Argument, Frame, NKJP_Example, Position
+from dictionary.models import Argument, Frame, Lemma, NKJP_Example, Position
 from semantics.change_log import store_old_versions
 from semantics.models import Complement, GeneralSelectivePreference, FramePosition,\
                              LexicalUnitExamples, RelationalSelectivePreference, \
@@ -278,8 +278,9 @@ def remove_preference(frame_id, complement_id, preference):
         complement.selective_preference.relations.remove(r)
-def update_meanings(operations):
+def update_meanings(lemma_id, operations):
     translation = {}
+    entry = Lemma.objects.get(id=lemma_id).entry_obj
     for operation in operations:
         if operation['operation'] == "set_glossa":
             if int(operation['unit']) in translation:
@@ -300,7 +301,7 @@ def update_meanings(operations):
                 unit = int(operation['unit'])
             remove_example(unit, operation['example'])
         elif operation['operation'] == "add_unit":
-            translation[operation['unit']['id']] = add_unit(operation['unit'])
+            translation[operation['unit']['id']] = add_unit(entry, operation['unit'])
         elif operation['operation'] == "remove_unit":
             luid = int(operation['luid'])
             if luid in translation:
@@ -327,11 +328,11 @@ def remove_example(unit_id, example_id):
     lue = LexicalUnitExamples.objects.get(example=nkjp_example, lexical_unit=unit)
     lue.delete()
-def add_unit(unit): # returns new id
+def add_unit(entry, unit): # returns new id
     s1 = Synset(id=(min(Synset.objects.all().aggregate(Min('id'))['id__min'], 0) - 1))
     s1.save()
-    lu = LexicalUnit(base=unit['base'], sense=unit['sense'], pos=unit['pos'], glossa=unit['glossa'], luid=-1, synset=s1)
+    lu = LexicalUnit(entry=entry, base=unit['base'], sense=unit['sense'], pos=unit['pos'], glossa=unit['glossa'], luid=-1, synset=s1)
     lu.save()
@@ -19,5 +19,10 @@ SEMANTIC_PATTERNS = patterns(&#39;semantics.views&#39;,
     url(r'^ajax/update_meanings/$', 'ajax_update_meanings'),
     url(r'^ajax/modify_frames/$', 'ajax_modify_frames'),
     url(r'^ajax/plWN_context_lookup/$', 'ajax_plWN_context_lookup'),
+    url(r'^ajax/synset_context_lookup/$', 'synset_context_lookup'),
     url(r'^ajax/validate_semantics/$', 'validate_semantics'),
+    url(r'^ajax/sem_arg_form/$', 'sem_arg_form'),
+    url(r'^ajax/general_preference_form/$', 'general_preference_form'),
+    url(r'^ajax/synset_preference_form/$', 'synset_preference_form'),
+    url(r'^ajax/relational_preference_form/$', 'relational_preference_form'),
 )
+<p class="fieldWrapper">
+  {{ form.general_pref.errors }} + {{ form.general_pref.label_tag }}: {{ form.general_pref }}
+  <button type="button" onclick="removeSelPreferenceFilter(this)">Usuń</button>
+</p>
 \ No newline at end of file
+<p class="fieldWrapper">
+  {{ form.relational_pref_relation.errors }} + {{ form.relational_pref_relation.label_tag }}: {{ form.relational_pref_relation }}
+  {{ form.relational_pref_role.errors }} Do: {{ form.relational_pref_role }}
+  {{ form.relational_pref_attribute.errors }} {{ form.relational_pref_attribute }}
+  <button type="button" onclick="removeSelPreferenceFilter(this)">Usuń</button>
+</p>
 \ No newline at end of file
+{% if form == 'or' %}
+    <div>
+      <hr class="alterSeparator">
+      <input type="hidden" name="or" value="or"><strong>lub</strong>
+      <button type="button" onclick="removeAlternative(this)">Usuń</button>
+    </div>
+{% else %}
+	<hr class="argSeparator">
+	<p class="fieldWrapper">
+	  {{ form.negation.errors }} {{ form.negation }}
+	  {{ form.role.errors }} {{ form.role.label_tag }}: {{ form.role }}
+	  {{ form.attribute.errors }} {{ form.attribute.label_tag }}: {{ form.attribute }}
+	  <button type="button" onclick="removeSemArgFilter(this)">Usuń</button>
+	</p>
+	<div id="selectional-preferences">
+	  <p>{{ form.preference_type.errors }} {{ form.preference_type.label_tag }}: {{ form.preference_type }} <button type="button" onclick="addSelectivePreferenceFilter(this)">Dodaj</button></p>
+	  {% for pref_form in form.preferences %}
+	    <p id="sel-preference">
+	      {% if pref_form.pref_type == 'general' %}
+		    {% include 'general_preference_form.html' with form=pref_form only %}
+		  {% elif pref_form.pref_type == 'relational' %}
+		    {% include 'relational_preference_form.html' with form=pref_form only %}
+		  {% elif pref_form.pref_type == 'synset' %}
+		    {% include 'synset_preference_form.html' with form=pref_form only %}
+		  {% endif %}
+		</p>
+	  {% endfor %}
+	</div>
+{% endif %}
 \ No newline at end of file
+<p class="fieldWrapper">
+  {{ form.synset_pref.errors }} + {{ form.synset_pref.label_tag }}: {{ form.synset_pref }}
+  <button type="button" onclick="removeSelPreferenceFilter(this)">Usuń</button>
+  <script type="text/javascript">
+	  $(function(){ 
+	     $('input#id_synset_pref').autocomplete({  
+		   select: function(event, ui){
+	 	   },
+	       source: function(req, add){
+	            $.getJSON(ajax_synset_context_lookup, req, function(data) { 
+	                var suggestions = [];  
+	                $.each(data['result'], function(i, val){  
+	                  suggestions.push(val);  
+	            }); 
+	            add(suggestions);  
+	        });  
+	      },  
+		});
+	  });
+  </script>
+</p>
 \ No newline at end of file
@@ -2,7 +2,7 @@
 from django.db.models import Max
-from dictionary.models import Lemma, reflex_phrase_types, Argument_Model
+from dictionary.models import Lemma, reflex_phrase_types
 from semantics.models import LexicalUnitExamples
 from semantics.utils import get_structural_matching_frame
@@ -182,7 +182,7 @@ def schema_used(schema, frames):
 def validate_lexical_units(lemma_id):
     error_msg = ''
     lemma = Lemma.objects.get(id=lemma_id, old=False)
-    lexical_units = lemma.entry_obj.lexical_units()
+    lexical_units = lemma.entry_obj.meanings
     for lex_unit in lexical_units.all():
         if not examples_reflex_agreed(lex_unit):
             error_msg = u'Semantyka: Znaczenie %s ma podpięte przykłady o niezgodnej zwrotności.' % unicode(lex_unit)
@@ -15,6 +15,7 @@ from django.core.urlresolvers import reverse
 from django.db.models import Q
 from common.decorators import render, ajax
+from semantics.forms import GeneralSelPrefForm, RelationalSelPrefForm, RoleForm, SynsetSelPrefForm 
 from semantics.saving import modify_frames, update_meanings
 from semantics.validation import validate_schemas, validate_frames, validate_lexical_units
@@ -79,7 +80,7 @@ def create_frames_context(lemma_id):
     lemma = Lemma.objects.get(id=lemma_id)
     #lexical_units = LexicalUnit.objects.filter(Q(base__startswith=lemma.entry + u' ')|Q(base__contains=u' '+lemma.entry+u' ')|Q(base__endswith=u' '+lemma.entry)|Q(base=lemma.entry)).order_by('sense')
-    lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się')).order_by('sense')
+    lexical_units = lemma.entry_obj.meanings.order_by('sense')
     alternations = {}        
     frames_dict = {}
@@ -216,7 +217,7 @@ def ajax_units(request, lemma_id):
 def create_units_context(lemma_id):
     lemma = Lemma.objects.get(id=lemma_id)
-    lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry, pos="czasownik")|Q(base = lemma.entry + u' się', pos="czasownik")).order_by('base', 'sense')
+    lexical_units = lemma.entry_obj.meanings.order_by('base', 'sense')
 #    lexical_units = LexicalUnit.objects.filter(Q(base__startswith=lemma.entry + u' ', pos="czasownik")|Q(base__contains=u' '+lemma.entry+u' ', pos="czasownik")|Q(base__endswith=u' '+lemma.entry, pos="czasownik")|Q(base=lemma.entry, pos="czasownik")).order_by('base', 'sense')
     context = {
@@ -354,7 +355,7 @@ def ajax_schemas(request, lemma_id):
             schemas_by_characteristic[characteristic_id] = []
         schemas_by_characteristic[characteristic_id].append(schema)
-    lexical_units = LexicalUnit.objects.filter(Q(base=lemma.entry) | Q(base=lemma.entry+u' się'))
+    lexical_units = lemma.entry_obj.meanings.all()
     schemas_display = []
     schema_unit_rank = {}
@@ -414,7 +415,7 @@ def ajax_examples(request, lemma_id):
     lemma = Lemma.objects.get(id=lemma_id).entry_obj.actual_lemma()
     nkjp_examples = lemma.nkjp_examples.all()
-    lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się'))
+    lexical_units = lemma.entry_obj.meanings.all()
     lexical_units_ids = [lu.id for lu in lexical_units]
@@ -488,7 +489,7 @@ def ajax_create_complement(request, lemma_id, frame, roles):
 @ajax(method='post', encode_result=True)
 def ajax_update_meanings(request, operations, lemma_id):
-    update_meanings(operations)
+    update_meanings(lemma_id, operations)
     units_context = create_units_context(lemma_id)
     return units_context
@@ -519,6 +520,19 @@ def get_ordered_lexical_units_bases(lexical_units_query):
         last_unit_base = lexical_unit.base
     return lexical_unit_bases
+@ajax(method='get', encode_result=True)         
+def synset_context_lookup(request, term):
+    results = []
+    term = unicode(term)
+    if len(term) > 0:
+        obj_results = LexicalUnit.objects.filter(base__startswith=term)
+        results = get_ordered_lexical_units(obj_results)
+    return {'result': results}
+
+def get_ordered_lexical_units(lexical_units_query):
+    ordered_lexical_units = lexical_units_query.order_by('base', 'sense')
+    return [unicode(lu) for lu in ordered_lexical_units]
+
 @ajax(method='get')
 def validate_semantics(request, lemma_id, new_status_id):
     error_msg = ''
@@ -536,3 +550,27 @@ def validate_semantics(request, lemma_id, new_status_id):
             if not error_msg:
                 error_msg = validate_schemas(lemma_id)
     return {'error_message': error_msg}
+
+@render('sem_arg_form.html')
+@ajax(method='get', encode_result=False)
+def sem_arg_form(request):
+    form = RoleForm()
+    return {'form': form}
+
+@render('general_preference_form.html')
+@ajax(method='get', encode_result=False)
+def general_preference_form(request):
+    form = GeneralSelPrefForm()
+    return {'form': form}
+
+@render('synset_preference_form.html')
+@ajax(method='get', encode_result=False)
+def synset_preference_form(request):
+    form = SynsetSelPrefForm()
+    return {'form': form}
+
+@render('relational_preference_form.html')
+@ajax(method='get', encode_result=False)
+def relational_preference_form(request):
+    form = RelationalSelPrefForm()
+    return {'form': form}
@@ -202,6 +202,7 @@ function resetForm($form) {
     $form.find('input:text, input:password, input:file, select, textarea').val('');
     $form.find('input:radio, input:checkbox')
          .removeAttr('checked').removeAttr('selected');
+    $form.find('#sem-arguments').remove();
 }
 // funkcja konwertujaca kody html znakow do znakow
@@ -33,6 +33,8 @@ class LexicalUnit(models.Model):
     definition = models.TextField(default="")
         # glossa
     glossa = models.TextField(default="")
+        # haslo w Walentym
+    entry = models.ForeignKey('dictionary.Entry', null=True, related_name='meanings')
     def __unicode__(self):
         return u'%s-%s' % (self.base, self.sense)