Added possibility to copy schema elements between nouns and adjectives.

Bartłomiej Nitoń
1 parent aa27b539
Showing 4 changed files with 59 additions and 19 deletions
dictionary/ajax_lemma_view.py
dictionary/convert_frames.py
dictionary/models.py
dictionary/validation.py
@@ -44,7 +44,7 @@ from dictionary.models import Vocabulary, Lemma, Lemma_Status, Frame_Opinion, \
                               sorted_default_frame_char_vals, XcpExample, \
                               POS, get_frame_char_and_its_value, get_frame_char_by_type_and_value_pk, \
                               sortFrameChars, sortArguments, sortPositions, \
-                              get_or_create_position, get_phraseologic_frames_only
+                              get_or_create_position, get_phraseologic_frames_only, pos_compatible
 from dictionary.forms import AddPositionForm, FrameForm, Pos_Cat_Form, \
                              AddNkjpExampleForm, MessageForm, SortForm, FilterForm, \
                              SimilarLemmasNewForm, ChangeUserFunctionForm, \
@@ -1395,24 +1395,30 @@ def need_conversion(request, from_lemma_id, to_lemma_id):
     from_entry = Entry.objects.get(name=from_lemma.entry)
     to_lemma = Lemma.objects.get(id=to_lemma_id)
     to_entry = Entry.objects.get(name=to_lemma.entry)
-    if not from_entry.pos.tag == to_entry.pos.tag:
+    if not pos_compatible(from_entry.pos, to_entry.pos):
         need_conversion = True
-    if (to_entry.rel_entries.filter(pk=from_entry.pk).exists() and
-        from_entry.pos.tag == 'verb' and 
-        (to_entry.pos.tag == 'noun' or to_entry.pos.tag == 'adj')):
+    if conversion_possible(from_entry, to_entry):
         can_be_converted = True
     return {'can_be_converted': can_be_converted,
             'need_conversion': need_conversion}
  
+def conversion_possible(from_entry, to_entry):
+    can_be_converted = False
+    if (to_entry.rel_entries.filter(pk=from_entry.pk).exists() and
+        from_entry.pos.tag == 'verb' and 
+        (to_entry.pos.tag == 'noun' or to_entry.pos.tag == 'adj')):
+        can_be_converted = True
+    return can_be_converted
+        
 @ajax(method='get')
 def get_compatible_schema_chars(request, lemma_id, schema_id):
     schema_chars = []
+    lemma = Lemma.objects.get(id=lemma_id)
     schema = Frame.objects.get(id=schema_id)
     schema_char_objs = sortFrameChars(schema.characteristics.all())
  
     if (not request.user.has_perm('dictionary.add_syntactic_frames') and 
         not request.user.is_superuser):
-        lemma = Lemma.objects.get(id=lemma_id)
         for char in schema_char_objs:
             possible_values = get_frame_char_values(char.type, lemma, True)
             if possible_values.filter(id=char.value.id).exists():
@@ -1420,7 +1426,12 @@ def get_compatible_schema_chars(request, lemma_id, schema_id):
             else:
                 schema_chars.append(possible_values.all()[0].value)
     else:
-        schema_chars = [char.value.value for char in schema_char_objs]
+        for char in schema_char_objs:
+            possible_values = get_frame_char_values(char.type, lemma, False)
+            if possible_values.filter(id=char.value.id).exists():
+                schema_chars.append(char.value.value)
+            else:
+                schema_chars.append(possible_values.all()[0].value)
  
     return {'schema_chars': schema_chars}
  
@@ -2569,7 +2580,7 @@ def validate_new_frames(request, data, id, examples, lemma_examples,
  
   serialized_frames = []
   error = False
-  if status_need_examples_check and not status_need_validation: #z tymi warunkami jest blad, patrz haslo adresowac
+  if status_need_examples_check and not status_need_validation:
       serialized_frames, error = validate_examples_and_mark_errors(old_object, status_obj, selected_frame_id)
   elif status_need_validation or not status_obj:
       serialized_frames, error = validate_schemas_and_mark_errors(old_object, status_obj, selected_frame_id)
@@ -2611,6 +2622,7 @@ def validate_new_frames(request, data, id, examples, lemma_examples,
           for miss_frame in missmatched_B_frames:
               message_content += u'\t- %s\n' % (miss_frame.text_rep)
           message_content += '\n'
+      message_content += deriv_miss_frames_msg
       if len(frames_to_merge) > 0:
           message_content += u'Sugerowane jest połączenie poniższych schematów, zawierają one często koordynujące się typy fraz:\n'
           for comb in frames_to_merge:
@@ -2618,7 +2630,6 @@ def validate_new_frames(request, data, id, examples, lemma_examples,
                                                                           comb['frames'][1].id, comb['frames'][1].text_rep,
                                                                           comb['occurrences'])
           message_content += '\n'
-      message_content += deriv_miss_frames_msg
       if message_content: 
           if status_need_validation:           
               message_content += u'Czy jesteś pewien, że chcesz zmienić status hasła?'
@@ -41,6 +41,12 @@ def frame_conversion(frame, from_pos, to_pos):
     elif from_pos.tag == 'verb' and to_pos.tag == 'adj':
         arg_conversion_function = verb_to_adj_arg_conversion
         frame_realizations = verb_to_adj_conversion(frame)
+    elif from_pos.tag == 'noun' and to_pos.tag == 'adj':
+        arg_conversion_function = noun_to_adj_arg_conversion
+        frame_realizations = noun_to_adj_conversion(frame)
+    elif from_pos.tag == 'adj' and to_pos.tag == 'noun':
+        arg_conversion_function = adj_to_noun_arg_conversion
+        frame_realizations = adj_to_noun_conversion(frame)
     frame_versions = create_frame_versions(frame_realizations, arg_conversion_function)
     return frame_versions
  
@@ -79,6 +85,12 @@ def verb_to_adj_arg_conversion(position_category, argument):
         argument = change_str_to_gen(argument)
     return argument 
  
+def noun_to_adj_arg_conversion(position_category, argument):
+    return argument
+
+def adj_to_noun_arg_conversion(position_category, argument):
+    return argument
+
 def change_str_to_gen(argument):
     arg_type, attributes_strs  = get_arg_parts(argument.text_rep)
     attributes_strs = ['gen' if attr_str=='str' else attr_str for attr_str in attributes_strs]
@@ -211,6 +223,14 @@ def verb_to_adj_conversion(frame):
     convert([{'from': ur'^subj\{np\(str\)\}$', 'to': ur'{prepnp(dla,gen)}'}, 
              {'from': ur'^obj\{np\(str\)\}$', 'to': None}], frame_realizations)
     return frame_realizations
+
+def noun_to_adj_conversion(frame):
+    frame_realizations = [frame_to_rule_format(frame)]
+    return frame_realizations
+
+def adj_to_noun_conversion(frame):
+    frame_realizations = [frame_to_rule_format(frame)]
+    return frame_realizations
  
 def frame_to_rule_format(frame):
     positions = [position_to_rule_format(position) 
@@ -1341,6 +1341,15 @@ class POS(Model):
     def __unicode__(self):
         return self.name
  
+def pos_compatible(from_pos, to_pos):
+    compatible = False
+    if from_pos == to_pos:
+        compatible = True
+    elif ((from_pos.tag == 'noun' and to_pos.tag == 'adj') or
+          (from_pos.tag == 'adj' and to_pos.tag == 'noun')):
+        compatible = True
+    return compatible
+    
 class XcpExample(Model):
     arg_regex = CharField(max_length=64, db_column='wzor_argumentu')
     #examples = ManyToManyField('NKJP_Example', related_name='xcp_examples')
@@ -210,16 +210,6 @@ def find_similar_frames(frames):
  
 ###################### walidacja powiazanych hasel (nieczasownikowe) #######################################
  
-def get_deriv_related_lemmas(entry):
-    deriv_related_lemmas = []
-    for rel_entry in entry.rel_entries.order_by('name'):
-        try:
-            rel_lemma = Lemma.objects.get(entry_obj=rel_entry, old=False)
-            deriv_related_lemmas.append(rel_lemma)
-        except Lemma.DoesNotExist:
-            pass
-    return deriv_related_lemmas
-
 def get_deriv_miss_frames_message(lemma):
     message_content = ''
     missing_frames = get_deriv_miss_frames(lemma)
@@ -248,6 +238,16 @@ def get_deriv_miss_frames(lemma):
                 add_missing_deriv_frame(missing_frames, frame, deriv_rel_lemma.entry_obj)
     return missing_frames
  
+def get_deriv_related_lemmas(entry):
+    deriv_related_lemmas = []
+    for rel_entry in entry.rel_entries.order_by('name'):
+        try:
+            rel_lemma = Lemma.objects.get(entry_obj=rel_entry, old=False)
+            deriv_related_lemmas.append(rel_lemma)
+        except Lemma.DoesNotExist:
+            pass
+    return deriv_related_lemmas
+
 def get_deriv_frames_to_check(lemma):
     lemma_frames = lemma.frames.order_by('text_rep')
     frames = [frame for frame in lemma_frames