Added statistics to auto generated package with Walenty in text format. Added ad…

…ditional statistics table to vocabulary management interface.

Added statistics to auto generated package with Walenty in text format. Added ad…
…ditional statistics table to vocabulary management interface.
Bartłomiej Nitoń
1 parent 3ad52b13
Showing 8 changed files with 222 additions and 146 deletions
dictionary/ajax_vocabulary_management.py
dictionary/management/commands/create_walenty.py
dictionary/management/commands/get_stats.py
dictionary/models.py
dictionary/static/js/manage-vocabularies.js
dictionary/templates/manage_vocabularies.html
dictionary/views.py
urls.py
@@ -24,10 +24,11 @@ import codecs
 import datetime
 import HTMLParser
 import os
+from collections import Counter
 from tempfile import mkdtemp, mkstemp
  
 from django.contrib.auth.models import User
-from django.db.models import Count, Sum, Q
+from django.db.models import Count, Max, Sum, Q
 from django.http import HttpResponse
 from django.template.loader import render_to_string
 from django.utils.encoding import smart_str
@@ -35,10 +36,12 @@ from django.utils.encoding import smart_str
 from common.decorators import ajax, AjaxError, render
 from dictionary.forms import ManageVocabPermForm
 from dictionary.models import Frame_Opinion_Value, Lemma, Lemma_Status, \
-                              POS, Vocabulary, VocabularyFormat, \
+                              POS, Vocabulary, VocabularyFormat, WalentyStat,\
                               sorted_frame_char_values_dict
 from dictionary.teixml import createteixml
  
+LEX_TYPES = ['lex', 'fixed', 'comprepnp']
+
 TEXT_VOCABULARY_CLAUSE = u"""
 % The Polish Valence Dictionary (Walenty)
 % <date>
@@ -319,4 +322,126 @@ def count_schemas(lemmas):
     if not schemas_count:
         schemas_count = 0
     return schemas_count
+
+@render('other_stats.html')
+@ajax(method='get', encode_result=False)
+def get_other_stats(request):
+    return WalentyStat.objects.order_by('label')
+
+def get_stats(statuses, pos):
+    stats_dict = Counter({u'phrases': 0,
+                          u'poss': 0,
+                          u'lemmas': 0,
+                          u'sub_lemmas': 0,
+                          u'schemata': 0,
+                          u'cer_schemata': 0,
+                          u'uncer_schemata': 0,
+                          u'bad_schemata': 0,
+                          u'arch_schemata': 0,
+                          u'col_schemata': 0,
+                          u'vul_schemata': 0,
+                          u'coor_schemata': 0,
+                          u'lex_schemata': 0,
+                          u'coor_lemmas': 0,
+                          u'lex_lemmas': 0})
+    
+    lemmas = Lemma.objects.filter(old=False, 
+                                  entry_obj__pos__tag=pos).filter(status__in=statuses).distinct()
+    stats_dict[u'lemmas'] = lemmas.count()
+    for lemma in lemmas.order_by('entry').all():
+        print lemma
+        stats_dict[u'cer_schemata'] += lemma.frame_opinions.filter(value__value=u'pewny').count()
+        stats_dict[u'uncer_schemata'] += lemma.frame_opinions.filter(value__value=u'wątpliwy').count()
+        stats_dict[u'bad_schemata'] += lemma.frame_opinions.filter(value__value=u'zły').count()
+        stats_dict[u'arch_schemata'] += lemma.frame_opinions.filter(value__value=u'archaiczny').count()
+        stats_dict[u'col_schemata'] += lemma.frame_opinions.filter(value__value=u'potoczny').count()
+        stats_dict[u'vul_schemata'] += lemma.frame_opinions.filter(value__value=u'wulgarny').count()
+        stats_dict[u'schemata'] += lemma.frames.count()
+
+        stats_dict = stats_dict + Counter(get_sub_entries_dict(lemma))
+                          
+        has_phraseology = False
+        has_coordination = False
+        for frame in lemma.frames.all():
+            stats_dict[u'poss'] += frame.positions.count()
+            flat_frames = frame.positions.annotate(num_args=Count('arguments')).aggregate(Max('num_args'))['num_args__max']
+            if flat_frames > 1:
+                stats_dict[u'coor_schemata'] += 1
+                has_coordination = True  
+            for pos in frame.positions.all():
+                stats_dict[u'phrases'] += pos.arguments.count()     
+            if frame.positions.filter(arguments__type__in=LEX_TYPES).exists():
+                stats_dict[u'lex_schemata'] += 1
+                has_phraseology = True
+                        
+        if has_phraseology:
+            stats_dict[u'lex_lemmas'] += 1
+        if has_coordination:
+            stats_dict[u'coor_lemmas'] += 1
+                     
+    return stats_dict
+
+def get_sub_entries_dict(lemma):
+    sub_entries_dict = {'sub_lemmas': 0}
+    frame_chars_dict = sorted_frame_char_values_dict()  
+    for reflex in frame_chars_dict['sorted_reflex_vals']:
+        for neg in frame_chars_dict['sorted_neg_vals']:
+            for pred in frame_chars_dict['sorted_pred_vals']:
+                for aspect in frame_chars_dict['sorted_aspect_vals']:
+                    matching_frames = lemma.get_frames_by_char_values(reflex_val=reflex, 
+                                                                      neg_val=neg, 
+                                                                      pred_val=pred, 
+                                                                      aspect_val=aspect)
+                    if matching_frames.exists():
+                        sub_entries_dict[u'sub_lemmas'] += 1
+                        subentry_key = u'Liczba podhaseł postaci: (%s,%s,%s,%s)' % (reflex.value, neg.value, 
+                                                                                    pred.value, aspect.value)
+                        if not subentry_key in sub_entries_dict:
+                            sub_entries_dict[subentry_key] = 0
+                        sub_entries_dict[subentry_key] += 1
+    return sub_entries_dict
+
+def write_stats(stats_path, stats):
+    try:
+        outfile = codecs.open(stats_path, 'wt', 'utf-8')
+        
+        outfile.write(u'Łączna liczba haseł:\t%d\n\n' % stats['lemmas'])
+        outfile.write(u'Łączna liczba pozycji w schematach:\t%d\n' % stats['poss'])
+        outfile.write(u'Łączna liczba realizacji w schematach:\t%d\n\n' % stats['phrases'])
+        
+        outfile.write(u'Łączna liczba podhaseł:\t%d\n' % stats['sub_lemmas'])
+        outfile.write(u'Liczba podhaseł postaci (ZWROTNOŚĆ, NEGATYWNOŚĆ, PREDYKATYWNOŚĆ, ASPEKT)\n')
+        write_subschemas_stats(outfile, stats)
+
+        outfile.write(u'Łączna liczba schematów:\t%d\n' % stats['schemata'])
+        outfile.write(u'Liczba schematów pewnych:\t%d\n' % stats['cer_schemata'])
+        outfile.write(u'Liczba schematów wątpliwych:\t%d\n' % stats['uncer_schemata'])       
+        outfile.write(u'Liczba schematów złych:\t%d\n' % stats['bad_schemata'])
+        outfile.write(u'Liczba schematów archaicznych:\t%d\n' % stats['arch_schemata'])
+        outfile.write(u'Liczba schematów potocznych:\t%d\n' % stats['col_schemata'])          
+        outfile.write(u'Liczba schematów wulgarnych:\t%d\n\n' % stats['vul_schemata'])
+        
+        outfile.write(u'Łączna liczba schematów z koordynacją:\t%d\n' % stats['coor_schemata'])
+        outfile.write(u'Łączna liczba schematów zleksykalizowanych:\t%d\n\n' % stats['lex_schemata'])
+        
+        outfile.write(u'Łączna liczba haseł zawierających pozycje z koordynacją:\t%d\n' % stats['coor_lemmas'])
+        outfile.write(u'Łączna liczba haseł zawierających schematy zleksykalizowane:\t%d\n\n' % stats['lex_lemmas'])                
+    finally:
+        outfile.close()
+        
+def write_subschemas_stats(stats_file, stats):
+    subschemas_stats = ['%s:\t%d\n' % (k, v) for k,v in stats.iteritems() if k.startswith(u'Liczba podhaseł postaci:')]
+    subschemas_stats.sort()
+    for stat in subschemas_stats:
+        stats_file.write(stat)
+    stats_file.write('\n')
+    
+def update_walenty_stats(stats):
+    WalentyStat.objects.all().delete()
+    WalentyStat(label=u'Łączna liczba haseł', value=str(stats['lemmas'])).save()
+    WalentyStat(label=u'Łączna liczba pozycji w schematach', value=str(stats['poss'])).save()
+    WalentyStat(label=u'Łączna liczba realizacji w schematach', value=str(stats['phrases'])).save()
+    WalentyStat(label=u'Łączna liczba schematów', value=str(stats['schemata'])).save()
+    WalentyStat(label=u'Łączna liczba schematów z koordynacją', value=str(stats['coor_schemata'])).save()
+    WalentyStat(label=u'Łączna liczba schematów zleksykalizowanych', value=str(stats['lex_schemata'])).save()
  
 \ No newline at end of file
 #-*- coding:utf-8 -*-
  
-#Copyright (c) 2013, Bartłomiej Nitoń
+#Copyright (c) 2015, Bartłomiej Nitoń
 #All rights reserved.
  
 #Redistribution and use in source and binary forms, with or without modification, are permitted provided 
@@ -23,11 +23,14 @@
 import datetime
 import os
 import tarfile
+from collections import Counter
  
 from django.core.management.base import BaseCommand
  
 from accounts.models import User
-from dictionary.ajax_vocabulary_management import create_text_walenty
+from dictionary.ajax_vocabulary_management import create_text_walenty, \
+                                                  get_stats, write_stats, \
+                                                  update_walenty_stats
 from dictionary.ajax_argument_realizations import create_realizations_file
 from dictionary.models import Frame_Opinion, Lemma, Vocabulary, POS, \
                               get_checked_statuses, get_ready_statuses
@@ -35,35 +38,49 @@ from settings import WALENTY_PATH
  
 class Command(BaseCommand):
     args = 'none'
-    help = 'Script for creating Walenty vocabulary.'
-
+    
     def handle(self, *args, **options):
-        filename_base = '%s_%s' % ('walenty', datetime.datetime.now().strftime('%Y%m%d'))
-        base_path = os.path.join(WALENTY_PATH, filename_base)
+        now = datetime.datetime.now().strftime('%Y%m%d')
+        filename_base = '%s_%s' % ('walenty', now)
         realizations_path = os.path.join(WALENTY_PATH, 
-                                     '%s_%s.txt' % ('phrase_types_expand', datetime.datetime.now().strftime('%Y%m%d')))
+                                     '   %s_%s.txt' % ('phrase_types_expand', now))
+        checked_stats_path = os.path.join(WALENTY_PATH, u'%s_%s' % (filename_base.replace('walenty', 'stats'), 
+                                                                    'verified'))
+        ready_stats_path = os.path.join(WALENTY_PATH, u'%s_%s' % (filename_base.replace('walenty', 'stats'), 
+                                                                  'all'))
         create_realizations_file(realizations_path)
         try:
+            all_stats = Counter({})
+            verified_stats = Counter({})
+            base_path = os.path.join(WALENTY_PATH, filename_base)
             archive = tarfile.open(base_path + '.tar.gz', 'w:gz')
             os.chdir(WALENTY_PATH)
             archive.add(os.path.basename(realizations_path))
             for pos in POS.objects.exclude(tag=u'unk').order_by('priority'):
-                create_pos_archive(archive, pos, filename_base)
+                pos_stats = create_pos_archive_and_get_stats(archive, pos, filename_base)
+                all_stats = all_stats + Counter(pos_stats['all'])
+                verified_stats = verified_stats + Counter(pos_stats['verified'])
+            write_stats(checked_stats_path, verified_stats)
+            archive.add(os.path.basename(checked_stats_path))
+            write_stats(ready_stats_path, all_stats)
+            archive.add(os.path.basename(ready_stats_path))
         finally:
             archive.close()
             os.remove(realizations_path)
+            os.remove(checked_stats_path)
+            os.remove(ready_stats_path)
  
-def create_pos_archive(archive, pos, filename_base):
+def create_pos_archive_and_get_stats(archive, pos, filename_base):
+    all_stats = {}
+    checked_stats = {}
     try:
-        all_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base, pos.tag, 'all'))
-        checked_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base, pos.tag, 'verified'))
         checked_statuses = get_checked_statuses()
         ready_statuses = get_ready_statuses()
-
         lemmas = Lemma.objects.filter(old=False, entry_obj__pos=pos).order_by('entry')
         checked_lemmas = lemmas.filter(status__in=checked_statuses)
         ready_lemmas = lemmas.filter(status__in=ready_statuses)
  
+        all_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base, pos.tag, 'all'))
         walenty_path_ready = create_text_walenty(file_name=all_path,
                                                  lemmas=ready_lemmas, 
                                                  vocabularies=Vocabulary.objects.none(), 
@@ -72,6 +89,10 @@ def create_pos_archive(archive, pos, filename_base):
                                                  owners=User.objects.none(), 
                                                  poss=POS.objects.filter(pk=pos.pk), 
                                                  add_frame_opinions=True)
+        all_filename = os.path.basename(walenty_path_ready)
+        archive.add(name=all_filename, arcname=os.path.join(u'%ss' % pos.tag, all_filename))
+        
+        checked_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base, pos.tag, 'verified'))
         walenty_path_checked = create_text_walenty(file_name=checked_path,
                                                    lemmas=checked_lemmas, 
                                                    vocabularies=Vocabulary.objects.none(), 
@@ -80,11 +101,29 @@ def create_pos_archive(archive, pos, filename_base):
                                                    owners=User.objects.none(), 
                                                    poss=POS.objects.filter(pk=pos.pk), 
                                                    add_frame_opinions=True)
-        all_filename = os.path.basename(walenty_path_ready)
         checked_filename = os.path.basename(walenty_path_checked)
-        archive.add(name=all_filename, arcname=os.path.join(u'%ss' % pos.tag, all_filename))
         archive.add(name=checked_filename, arcname=os.path.join(u'%ss' % pos.tag, checked_filename))
+        
+        all_stats = get_stats(ready_statuses, pos.tag)
+        all_stats_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base.replace('walenty', 'stats'), 
+                                                                    pos.tag, 'all'))
+        write_stats(all_stats_path, all_stats)
+        all_stats_filename = os.path.basename(all_stats_path)
+        archive.add(name=all_stats_filename, arcname=os.path.join(u'%ss' % pos.tag, all_stats_filename))
+        
+        checked_stats = get_stats(checked_statuses, pos.tag)
+        checked_stats_path = os.path.join(WALENTY_PATH, u'%s_%ss_%s' % (filename_base.replace('walenty', 'stats'), 
+                                                                        pos.tag, 'verified'))
+        write_stats(checked_stats_path, checked_stats)
+        checked_stats_filename = os.path.basename(checked_stats_path)
+        archive.add(name=checked_stats_filename, arcname=os.path.join(u'%ss' % pos.tag, checked_stats_filename))
+        
+        update_walenty_stats(all_stats)
     finally:
-        os.remove(walenty_path_checked)
         os.remove(walenty_path_ready)
+        os.remove(walenty_path_checked)
+        os.remove(all_stats_path)
+        os.remove(checked_stats_path)
+        return {'all': all_stats,
+                'verified': checked_stats}
  
 \ No newline at end of file
 #-*- coding:utf-8 -*-
-# author: B.Niton
  
-import codecs
 import datetime
 from collections import Counter
  
 from django.core.management.base import BaseCommand
-from django.db.models import Count, Max
  
-from dictionary.models import Lemma, get_checked_statuses, get_ready_statuses, \
-                              sorted_frame_char_values_dict
-
-LEX_TYPES = ['lex', 'fixed', 'comprepnp']
+from dictionary.models import get_checked_statuses, get_ready_statuses
+from dictionary.ajax_vocabulary_management import get_stats, write_stats
  
 class Command(BaseCommand):
     help = 'Get Walenty statistics.'
@@ -21,126 +16,28 @@ class Command(BaseCommand):
         all_statuses = get_ready_statuses()
         verified_statuses = get_checked_statuses()
  
-#        nouns_stats_dict_all = Counter(get_stats('data/statystyki_2015_06_30_nouns_all.txt', all_statuses, 'noun'))
-#        nouns_stats_dict_verified = Counter(get_stats('data/statystyki_2015_06_30_nouns_verified.txt', verified_statuses, 'noun')) 
-
-#        adjs_stats_dict_all = Counter(get_stats('data/statystyki_2015_06_30_adjs_all.txt', all_statuses, 'adj'))
-#        adjs_stats_dict_verified = Counter(get_stats('data/statystyki_2015_06_30_adjs_verified.txt', verified_statuses, 'adj'))
-#        
-#        verbs_stats_dict_all = Counter(get_stats('data/statystyki_2015_06_30_verbs_all.txt', all_statuses, 'verb'))
-#        verbs_stats_dict_verified = Counter(get_stats('data/statystyki_2015_06_30_verbs_verified.txt', verified_statuses, 'verb'))
-#        
-        advs_stats_dict_all = Counter(get_stats(all_statuses, 'adv'))
-        write_stats('data/stats_%s_advs_all.txt' % now, advs_stats_dict_all)
-#        advs_stats_dict_verified = Counter(get_stats('data/statystyki_2015_06_30_advs_verified.txt', verified_statuses, 'adv'))
-#        
-#        all_stats_dict_all = nouns_stats_dict_all + adjs_stats_dict_all + verbs_stats_dict_all + advs_stats_dict_all
-#        all_stats_dict_verified = nouns_stats_dict_verified + adjs_stats_dict_verified + verbs_stats_dict_verified + advs_stats_dict_verified
-#        
-#        write_all_stats('data/statystyki_2015_06_30_all.txt', all_stats_dict_all)
-#        write_all_stats('data/statystyki_2015_06_30_verified.txt', all_stats_dict_verified)
-        
-def write_stats(stats_path, stats_dict):
-    try:
-        outfile = codecs.open(stats_path, 'wt', 'utf-8')
+        nouns_stats_dict_all = Counter(get_stats(all_statuses, 'noun'))
+        write_stats('data/stats_%s_nouns_all.txt' % now, nouns_stats_dict_all)
+        nouns_stats_dict_verified = Counter(get_stats(verified_statuses, 'noun')) 
+        write_stats('data/stats_%s_nouns_verified.txt' % now, nouns_stats_dict_verified)
  
-        outfile.write(u'Liczba typów fraz:\t%d\n' % stats_path['phrases'])
-        outfile.write(u'Liczba pozycji:\t%d\n' % stats_path['poss'])
-        outfile.write(u'Liczba haseł:\t%d\n\n' % stats_path['lemmas'])
+        adjs_stats_dict_all = Counter(get_stats(all_statuses, 'adj'))
+        write_stats('data/stats_%s_adjs_all.txt' % now, adjs_stats_dict_all)
+        adjs_stats_dict_verified = Counter(get_stats(verified_statuses, 'adj'))
+        write_stats('data/stats_%s_adjs_verified.txt' % now, adjs_stats_dict_verified)
  
-        outfile.write(u'Łączna liczba podhaseł:\t%d\n' % stats_path['sub_lemmas'])
-        outfile.write(u'Liczba podhaseł postaci (ZWROTNOŚĆ, NEGATYWNOŚĆ, PREDYKATYWNOŚĆ, ASPEKT)\n')
-#### dokonczyc
-
-        outfile.write(u'Łączna liczba schematów:\t%d\n' % stats_path['schemata'])
-        outfile.write(u'Liczba schematów pewnych:\t%d\n' % stats_path['cer_schemata'])
-        outfile.write(u'Liczba schematów wątpliwych:\t%d\n' % stats_path['uncer_schemata'])       
-        outfile.write(u'Liczba schematów złych:\t%d\n' % stats_path['bad_schemata'])
-        outfile.write(u'Liczba schematów archaicznych:\t%d\n' % stats_path['arch_schemata'])
-        outfile.write(u'Liczba schematów potocznych:\t%d\n' % stats_path['col_schemata'])          
-        outfile.write(u'Liczba schematów wulgarnych:\t%d\n\n' % stats_path['vul_schemata'])
+        verbs_stats_dict_all = Counter(get_stats(all_statuses, 'verb'))
+        write_stats('data/stats_%s_verbs_all.txt' % now, verbs_stats_dict_all)
+        verbs_stats_dict_verified = Counter(get_stats(verified_statuses, 'verb'))
+        write_stats('data/stats_%s_verbs_verified.txt' % now, verbs_stats_dict_verified)
  
-        outfile.write(u'Liczba schematów z koordynacją:\t%d\n' % stats_path['coor_schemata'])
-        outfile.write(u'Liczba schematów zleksykalizowanych:\t%d\n\n' % stats_path['lex_schemata'])
+        advs_stats_dict_all = Counter(get_stats(all_statuses, 'adv'))
+        write_stats('data/stats_%s_advs_all.txt' % now, advs_stats_dict_all)
+        advs_stats_dict_verified = Counter(get_stats(verified_statuses, 'adv'))
+        write_stats('data/stats_%s_advs_verified.txt' % now, advs_stats_dict_verified)
  
-        outfile.write(u'Hasła zawierające pozycje z koordynacją:\t%d\n' % stats_path['coor_lemmas'])
-        outfile.write(u'Hasła zawierające schematy zleksykalizowane:\t%d\n\n' % stats_path['lex_lemmas'])                
+        all_stats_dict_all = nouns_stats_dict_all + adjs_stats_dict_all + verbs_stats_dict_all + advs_stats_dict_all
+        all_stats_dict_verified = nouns_stats_dict_verified + adjs_stats_dict_verified + verbs_stats_dict_verified + advs_stats_dict_verified
  
-    except:
-        outfile.close()
-
-def get_stats(statuses, pos):
-    stats_dict = Counter({u'phrases': 0,
-                          u'poss': 0,
-                          u'lemmas': 0,
-                          u'sub_lemmas': 0,
-                          u'schemata': 0,
-                          u'cer_schemata': 0,
-                          u'uncer_schemata': 0,
-                          u'bad_schemata': 0,
-                          u'arch_schemata': 0,
-                          u'col_schemata': 0,
-                          u'vul_schemata': 0,
-                          u'coor_schemata': 0,
-                          u'lex_schemata': 0,
-                          u'coor_lemmas': 0,
-                          u'lex_lemmas': 0})
-    
-    lemmas = Lemma.objects.filter(old=False, 
-                                  entry_obj__pos__tag=pos).filter(status__in=statuses).distinct()
-    for lemma in lemmas.order_by('entry').all():
-        print lemma
-        stats_dict[u'lemmas'] += 1
-        stats_dict[u'cer_schemata'] += lemma.frame_opinions.filter(value__value=u'pewny').count()
-        stats_dict[u'uncer_schemata'] += lemma.frame_opinions.filter(value__value=u'wątpliwy').count()
-        stats_dict[u'bad_schemata'] += lemma.frame_opinions.filter(value__value=u'zły').count()
-        stats_dict[u'arch_schemata'] += lemma.frame_opinions.filter(value__value=u'archaiczny').count()
-        stats_dict[u'col_schemata'] += lemma.frame_opinions.filter(value__value=u'potoczny').count()
-        stats_dict[u'vul_schemata'] += lemma.frame_opinions.filter(value__value=u'wulgarny').count()
-        stats_dict[u'schemata'] += lemma.frames.count()
-
-        stats_dict = stats_dict + Counter(get_sub_entries_dict(lemma))
-                          
-        has_phraseology = False
-        has_coordination = False
-        for frame in lemma.frames.all():
-            stats_dict[u'poss'] += frame.positions.count()
-            flat_frames = frame.positions.annotate(num_args=Count('arguments')).aggregate(Max('num_args'))['num_args__max']
-            if flat_frames > 1:
-                stats_dict[u'coor_schemata'] += 1
-                has_coordination = True  
-            for pos in frame.positions.all():
-                stats_dict[u'phrases'] += pos.arguments.count()     
-            if frame.positions.filter(arguments__type__in=LEX_TYPES).exists():
-                stats_dict[u'lex_schemata'] += 1
-                has_phraseology = True
-                        
-        if has_phraseology:
-            stats_dict[u'lex_lemmas'] += 1
-        if has_coordination:
-            stats_dict[u'coor_lemmas'] += 1
-            
-    return stats_dict
-
-def get_sub_entries_dict(lemma):
-    sub_entries_dict = {}
-    frame_chars_dict = sorted_frame_char_values_dict()  
-    for reflex in frame_chars_dict['sorted_reflex_vals']:
-        for neg in frame_chars_dict['sorted_neg_vals']:
-            for pred in frame_chars_dict['sorted_pred_vals']:
-                for aspect in frame_chars_dict['sorted_aspect_vals']:
-                    matching_frames = lemma.get_frames_by_char_values(reflex_val=reflex, 
-                                                                      neg_val=neg, 
-                                                                      pred_val=pred, 
-                                                                      aspect_val=aspect)
-                    if matching_frames.exists():
-                        if not u'sub_lemmas' in sub_entries_dict:
-                            sub_entries_dict[u'sub_lemmas'] = 0
-                        sub_entries_dict[u'sub_lemmas'] += 1
-                        
-                        subentry_key = u'Liczba podhaseł postaci: (%s,%s,%s,%s)' % (reflex.value, neg.value, 
-                                                                                    pred.value, aspect.value)
-                        if not subentry_key in sub_entries_dict:
-                            sub_entries_dict[subentry_key] = 0
-                        sub_entries_dict[subentry_key] += 1
-    return sub_entries_dict
+        write_stats('data/stats_%s_all.txt' % now, all_stats_dict_all)
+        write_stats('data/stats_%s_verified.txt' % now, all_stats_dict_verified)
@@ -46,8 +46,15 @@ class VocabularyFormat(Model):
     format = CharField(max_length=64, primary_key=True, unique=True, db_column='format_slownika')
  
     def __unicode__(self):
-      return '%s' % self.format 
- 
+        return '%s' % self.format
+  
+class WalentyStat(Model):
+    date = DateTimeField(auto_now_add=True, db_column='data_aktualizacji')
+    label = CharField(max_length=128, db_column='etykieta')
+    value = CharField(max_length=16, db_column='wartosc')
+    
+    def __unicode__(self):
+        return '%s:\t%s' % (self.label, self.value)
  
 class Vocabulary(Model):
     name = CharField(max_length=64, primary_key=True, unique=True, db_column='slownik') 
@@ -14,6 +14,7 @@ $(function() {
   $('form.voc-download-form').live('submit', download_form_submit);
   $('#vocabulary-select').live('change', show_vocabulary_info);
   $('form.vocab-perm-manage-form').live('submit', vocab_perm_manage_form_submit);
+  $('#other-statistisc').load(ajax_get_other_stats);
   show_vocabulary_info(); 
 });
  
@@ -40,6 +40,12 @@
       </div>
     </td>
   </tr>
+  <tr>
+    <td colspan='2'>
+      <div id="other-statistisc" style="vertical-align:top;">
+      </div>
+    </td>
+  </tr>
 </table>
  
 {% if perms.dictionary.download_vocabulary %}
@@ -351,6 +351,7 @@ def manage_vocabulary(request):
     'ajax_vocab_perm_manage_form': reverse('vocab_perm_manage_form'),
     'ajax_vocab_perm_manage_form_submit': reverse('vocab_perm_manage_form_submit'),
     'ajax_get_vocabulary_stats': reverse('get_vocabulary_stats'),
+    'ajax_get_other_stats': reverse('get_other_stats')
   }
   return to_return
  
@@ -210,7 +210,6 @@ urlpatterns += patterns(&#39;dictionary.views&#39;,
   url(r'^wszystkie_statystyki/$', 'all_statistics'),
   url(r'^zarzadzanie_kontami/$', 'manage_users'),
   url(r'^rozwiniecia_typow_fraz/$', 'manage_arg_realizations'),
-  #url(r'^statystyki_argumentow/$', 'arg_stats'),
   url(r'^pobieranie_slownika/$', 'download_walenty'),
 )
  
@@ -228,7 +227,8 @@ urlpatterns += patterns(&#39;dictionary.ajax_vocabulary_management&#39;,
   url(r'^ajax/create_vocabulary/$', 'create_vocabulary'),
   url(r'^ajax/vocab_perm_manage_form/$', 'vocab_perm_manage_form'),  
   url(r'^ajax/vocab_perm_manage_form_submit/$', 'vocab_perm_manage_form_submit'),    
-  url(r'^ajax/get_vocabulary_stats/$', 'get_vocabulary_stats'),                     
+  url(r'^ajax/get_vocabulary_stats/$', 'get_vocabulary_stats'),
+  url(r'^ajax/get_other_stats/$', 'get_other_stats'),                  
 )
  
 urlpatterns += SEMANTIC_PATTERNS