diff --git a/README.md b/README.md
index 296f72d518a18d9eb069e8b60d6a0c23bc428cbe..7f8680288d615002ad51e0a8dc2cf2e41d57f576 100644
--- a/README.md
+++ b/README.md
@@ -77,3 +77,8 @@ Compiled application files will be located in `frontend/dist/`.
 
     export LOADING_THE_SLOWOSIEC_ONTOLOGY_HIERARCHY_DISABLED=true
     python manage.py test --settings=shellvalier.settings-test
+    
+## Database update for vertical relations
+
+    export LOADING_THE_SLOWOSIEC_ONTOLOGY_HIERARCHY_DISABLED=true
+    python manage.py db_import_relation_entries
diff --git a/frontend/src/components/unification/vertical_relations/VerticalRelationEdit.vue b/frontend/src/components/unification/vertical_relations/VerticalRelationEdit.vue
index e2067d401565d53dfd98b4b873a8b629092274a2..e10f6dbbbc74621cd26399e65ebf3bde97375127 100644
--- a/frontend/src/components/unification/vertical_relations/VerticalRelationEdit.vue
+++ b/frontend/src/components/unification/vertical_relations/VerticalRelationEdit.vue
@@ -217,8 +217,8 @@ export default {
         if(slowalFrame != null) {
           for (let j in slowal_frame_mapping.slowal_frame_argument_mapping) {
             const slowal_frame_argument_mapping = slowal_frame_mapping.slowal_frame_argument_mapping[j];
-            if (slowal_frame_argument_mapping.unified_frame_agrument_id == unified_frame_argument.id) {
-              const slowalFrameArgument = slowalFrame.arguments.find(arg => arg.argument_id === slowal_frame_argument_mapping.slowal_frame_agrument_id);
+            if (slowal_frame_argument_mapping.unified_frame_argument_id == unified_frame_argument.id) {
+              const slowalFrameArgument = slowalFrame.arguments.find(arg => arg.argument_id === slowal_frame_argument_mapping.slowal_frame_argument_id);
               slowalFrameArgumentIds.push(slowalFrameArgument);
             }
           }
@@ -243,8 +243,8 @@ export default {
     //     if(slowalFrame != null) {
     //       for (let j in slowal_frame_mapping.slowal_frame_argument_mapping) {
     //         const slowal_frame_argument_mapping = slowal_frame_mapping.slowal_frame_argument_mapping[j];
-    //         if (slowal_frame_argument_mapping.unified_frame_agrument_id == unified_frame_argument.id) {
-    //           const slowalFrameArgument = slowalFrame.arguments.find(arg => arg.argument_id === slowal_frame_argument_mapping.slowal_frame_agrument_id);
+    //         if (slowal_frame_argument_mapping.unified_frame_argument_id == unified_frame_argument.id) {
+    //           const slowalFrameArgument = slowalFrame.arguments.find(arg => arg.argument_id === slowal_frame_argument_mapping.slowal_frame_argument_id);
     //           slowalFrameArgumentIds.push(slowalFrameArgument);
     //         }
     //       }
@@ -354,9 +354,9 @@ export default {
       const used_argument_ids = new Set();
       for (let j in source_unified_frame.unified_frame_arguments) {
         const unified_frame_argument = source_unified_frame.unified_frame_arguments[j];
-        let unified_frame_argument_mapping = unified_frame_arguments_mapping.find(o => o.source_unified_agrument_id === unified_frame_argument.id);
+        let unified_frame_argument_mapping = unified_frame_arguments_mapping.find(o => o.source_unified_argument_id === unified_frame_argument.id);
         let slowal_frame_argument = null;
-        if (unified_frame_argument_mapping.target_unified_agrument_id == null) {
+        if (unified_frame_argument_mapping.target_unified_argument_id == null) {
           slowal_frame_argument = {
             'str': 'Empty',
             'unified_frame_argument_id': unified_frame_argument.id,
@@ -367,8 +367,8 @@ export default {
             'proposed_roles': [],
           }
         } else {
-          used_argument_ids.add(unified_frame_argument_mapping.target_unified_agrument_id);
-          slowal_frame_argument = target_unified_frame.unified_frame_arguments.find(o => o.id === unified_frame_argument_mapping.target_unified_agrument_id);
+          used_argument_ids.add(unified_frame_argument_mapping.target_unified_argument_id);
+          slowal_frame_argument = target_unified_frame.unified_frame_arguments.find(o => o.id === unified_frame_argument_mapping.target_unified_argument_id);
           slowal_frame_argument.unified_frame_argument_id = unified_frame_argument.id;
         }
         new_slowal_frame_arguments.push(slowal_frame_argument)
diff --git a/vertical_relations/models.py b/vertical_relations/models.py
index 45601ae152b84f8a9b5adc2875a90cc9faa6709d..c1b601a106aa401951fd912c13a090552ea38141 100644
--- a/vertical_relations/models.py
+++ b/vertical_relations/models.py
@@ -36,20 +36,14 @@ class VerticalRelationNegation(models.Model):
         return self.name
 
 
-class UnifiedFrameArgument2UnifiedFrameArgumentMapping(object):
-    pass
-
-
-class UnifiedFrameVerticalRelation(object):
-    pass
-
-
 class UnifiedFrameArgument2UnifiedFrameArgumentMapping(models.Model):
-    source_unified_agrument = models.ForeignKey(UnifiedFrameArgument, related_name='source_unified_agrument_mapping',
+    source_unified_argument = models.ForeignKey(UnifiedFrameArgument, related_name='source_unified_argument_mapping',
                                                 on_delete=models.PROTECT)
-    target_unified_agrument = models.ForeignKey(UnifiedFrameArgument, related_name='target_unified_agrument_mapping', blank=True, null=True, on_delete=models.PROTECT)
+    target_unified_argument = models.ForeignKey(UnifiedFrameArgument, related_name='target_unified_argument_mapping',
+                                                blank=True, null=True, on_delete=models.PROTECT)
     unified_frame_vertical_relation = models.ForeignKey('UnifiedFrameVerticalRelation',
-                                                        related_name='unified_frame_arguments_mapping', on_delete=models.PROTECT)
+                                                        related_name='unified_frame_arguments_mapping',
+                                                        on_delete=models.PROTECT)
 
 
 class UnifiedFrameVerticalRelation(models.Model):
@@ -62,24 +56,35 @@ class UnifiedFrameVerticalRelation(models.Model):
     temporal_vertical_relation = models.ManyToManyField(related_name='unified_frame_vertical_relation',
                                                         to=TemporalVerticalRelation)
     negation = models.ForeignKey(VerticalRelationNegation, related_name='vertical_relation_negation',
-                                   default=None, blank=True, null=True, on_delete=models.PROTECT)
-    negation_argument = models.ForeignKey(UnifiedFrameArgument, related_name='negation_argument',
                                  default=None, blank=True, null=True, on_delete=models.PROTECT)
+    negation_argument = models.ForeignKey(UnifiedFrameArgument, related_name='negation_argument',
+                                          default=None, blank=True, null=True, on_delete=models.PROTECT)
 
     subrelation = models.ForeignKey('UnifiedFrameVerticalRelation', related_name='subrelation_recursive',
-                                                      default=None, blank=True, null=True, on_delete=models.PROTECT)
-    temporal_vertical_relation_for_subrelation = models.ForeignKey(TemporalVerticalRelation, related_name='temporal_vertical_relation_for_subrelation',
-                                               default=None, blank=True, null=True, on_delete=models.PROTECT)
+                                    default=None, blank=True, null=True, on_delete=models.PROTECT)
+    temporal_vertical_relation_for_subrelation = models.ForeignKey(TemporalVerticalRelation,
+                                                                   related_name='temporal_vertical_relation_for_subrelation',
+                                                                   default=None, blank=True, null=True,
+                                                                   on_delete=models.PROTECT)
 
-    iter_temporal_vertical_relation = models.ForeignKey(TemporalVerticalRelation, related_name='iter_temporal_vertical_relation',
-                                                                   default=None, blank=True, null=True, on_delete=models.PROTECT)
+    iter_temporal_vertical_relation = models.ForeignKey(TemporalVerticalRelation,
+                                                        related_name='iter_temporal_vertical_relation',
+                                                        default=None, blank=True, null=True, on_delete=models.PROTECT)
 
     def __str__(self):
-        subrelation_str = (', sub: (iterated:' + self.subrelation.target_unified_frame.title + ' - ' +
-         (self.temporal_vertical_relation_for_subrelation.name if self.temporal_vertical_relation_for_subrelation else '') + ')') if self.subrelation and self.subrelation.target_unified_frame else ''
-
-        return str(self.id) + '::'+self.source_unified_frame.title + ':' + (self.target_unified_frame.title if self.target_unified_frame else '') + \
-               ' - ' + self.main_vertical_relation.name + ', ' +  (','.join([str(t) for t in self.temporal_vertical_relation.all()]) if self.temporal_vertical_relation else '') +\
-               (' (' + self.negation.name + ': ' + self.negation_argument.role.role.role + ')' if self.negation else '') + \
-               (' (iterated:' + str(self.iter_temporal_vertical_relation.name) + '] ' if self.iter_temporal_vertical_relation else '') +\
-               subrelation_str
+        subtelation_temporal = self.temporal_vertical_relation_for_subrelation.name \
+            if self.temporal_vertical_relation_for_subrelation else ''
+        subrelation_str = (', sub: (iterated:' + self.subrelation.target_unified_frame.title +
+                           ' - ' + subtelation_temporal + ')') \
+            if self.subrelation and self.subrelation.target_unified_frame else ''
+
+        target_title = self.target_unified_frame.title if self.target_unified_frame else ''
+        temporal_relations = ','.join(
+            [str(t) for t in self.temporal_vertical_relation.all()]) if self.temporal_vertical_relation else ''
+        negation = ' (' + self.negation.name + ': ' + self.negation_argument.role.role.role + ')' \
+            if self.negation else ''
+        iteration = ' (iterated:' + str(
+            self.iter_temporal_vertical_relation.name) + '] ' if self.iter_temporal_vertical_relation else ''
+        return '{0}::{1}:{2} - {3}, {4}{5}{6}{7}'.format(str(self.id), self.source_unified_frame.title, target_title,
+                                                         self.main_vertical_relation.name, temporal_relations, negation,
+                                                         iteration, subrelation_str)
diff --git a/vertical_relations/urls.py b/vertical_relations/urls.py
index 9e5dab5f23a3c3941cd354bb90472f673bddfded..50c0e07dceb336726f46220801a9c67d2983ef80 100644
--- a/vertical_relations/urls.py
+++ b/vertical_relations/urls.py
@@ -7,21 +7,24 @@ app_name = 'vertical_relations'
 urlpatterns = [
     path('save_main_vertical_relation/', views.save_main_vertical_relation, name='save_main_vertical_relation'),
     path('ajax_main_vertical_relations/', views.ajax_main_vertical_relations, name='ajax_main_vertical_relations'),
-    path('ajax_temporal_vertical_relations/', views.ajax_temporal_vertical_relations, name='ajax_temporal_vertical_relations'),
+    path('ajax_temporal_vertical_relations/', views.ajax_temporal_vertical_relations,
+         name='ajax_temporal_vertical_relations'),
     path('load_vertical_relation/', views.load_vertical_relation, name='load_vertical_relation'),
-    path('save_temporal_vertical_relation/', views.save_temporal_vertical_relation, name='save_temporal_vertical_relation'),
+    path('save_temporal_vertical_relation/', views.save_temporal_vertical_relation,
+         name='save_temporal_vertical_relation'),
     path('remove_vertical_relation/', views.remove_vertical_relation, name='remove_vertical_relation'),
     path('save_target_relation/', views.save_target_relation, name='save_target_relation'),
     path('remove_target_relation/', views.remove_target_relation, name='remove_target_relation'),
-    path('ajax_vertical_relation_negations/', views.ajax_vertical_relation_negations, name='ajax_vertical_relation_negations'),
-    path('save_vertical_relation_negation/', views.save_vertical_relation_negation, name='save_vertical_relation_negation'),
-    path('remove_vertical_relation_negation/', views.remove_vertical_relation_negation, name='remove_vertical_relation_negation'),
+    path('ajax_vertical_relation_negations/', views.ajax_vertical_relation_negations,
+         name='ajax_vertical_relation_negations'),
+    path('save_vertical_relation_negation/', views.save_vertical_relation_negation,
+         name='save_vertical_relation_negation'),
+    path('remove_vertical_relation_negation/', views.remove_vertical_relation_negation,
+         name='remove_vertical_relation_negation'),
     path('save_subrelation/', views.save_subrelation, name='save_subrelation'),
     path('remove_subrelation/', views.remove_subrelation, name='remove_subrelation'),
     path('save_iter_relation/', views.save_iter_relation, name='save_iter_relation'),
     path('remove_iter_relation/', views.remove_iter_relation, name='remove_iter_relation'),
     path('change_argument_mapping/', views.change_argument_mapping, name='change_argument_mapping'),
 
-
-
 ]
diff --git a/vertical_relations/views.py b/vertical_relations/views.py
index 710b386fae7fc3560e6c297e8d5e9d6e7c3ed728..6049809a45001a0ab3bee5acfdbc20ae5ab95feb 100644
--- a/vertical_relations/views.py
+++ b/vertical_relations/views.py
@@ -12,6 +12,11 @@ from vertical_relations.models import UnifiedFrameVerticalRelation, MainVertical
 
 @ajax(method='get', encode_result=True)
 def ajax_main_vertical_relations(request):
+    """
+    Retrieve list of available main relation types.
+    :param request: http request
+    :return: json response with 'main_vertical_relations' filed
+    """
     main_vertical_relations = []
     for main_vertical_relation in MainVerticalRelation.objects.order_by('priority'):
         main_vertical_relations.append({"id": main_vertical_relation.id, "name": main_vertical_relation.name})
@@ -25,9 +30,15 @@ def ajax_main_vertical_relations(request):
 
 @ajax(method='get', encode_result=True)
 def ajax_temporal_vertical_relations(request):
+    """
+    Retrieve list of available temporal relation types.
+    :param request: http request
+    :return: json response with 'temporal_vertical_relations' filed
+    """
     temporal_vertical_relations = []
     for temporal_vertical_relation in TemporalVerticalRelation.objects.order_by('priority'):
-        temporal_vertical_relations.append({"id": temporal_vertical_relation.id, "name": temporal_vertical_relation.name})
+        temporal_vertical_relations.append(
+            {"id": temporal_vertical_relation.id, "name": temporal_vertical_relation.name})
 
     context = {
         'temporal_vertical_relations': temporal_vertical_relations,
@@ -38,6 +49,11 @@ def ajax_temporal_vertical_relations(request):
 
 @ajax(method='get', encode_result=True)
 def ajax_vertical_relation_negations(request):
+    """
+    Retrieve list of available negation types.
+    :param request: http request
+    :return: json response with 'negations' filed
+    """
     negations = []
     for negation in VerticalRelationNegation.objects.order_by('priority'):
         negations.append({"id": negation.id, "name": negation.name})
@@ -52,17 +68,26 @@ def ajax_vertical_relation_negations(request):
 @ajax_required
 @transaction.atomic
 def save_main_vertical_relation(request):
+    """
+    Add main relation type to relation instance.
+    The request has to contain 'source_unified_frame_id', 'main_vertical_relation_id'
+    and optionally 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
         source_unified_frame_id = request.POST['source_unified_frame_id']
         target_unified_frame_id = request.POST['target_unified_frame_id']
         main_vertical_relation_id = request.POST['main_vertical_relation_id']
 
         if target_unified_frame_id:
-            relation, _ = UnifiedFrameVerticalRelation.objects.get_or_create(source_unified_frame_id=source_unified_frame_id,
-                                                                             target_unified_frame_id=target_unified_frame_id)
+            relation, _ = UnifiedFrameVerticalRelation.objects.get_or_create(
+                source_unified_frame_id=source_unified_frame_id,
+                target_unified_frame_id=target_unified_frame_id)
         else:
-            relation, _ = UnifiedFrameVerticalRelation.objects.get_or_create(source_unified_frame_id=source_unified_frame_id,
-                                                                             target_unified_frame_id=None)
+            relation, _ = UnifiedFrameVerticalRelation.objects.get_or_create(
+                source_unified_frame_id=source_unified_frame_id,
+                target_unified_frame_id=None)
 
         main_vertical_relation = MainVerticalRelation.objects.get(id=main_vertical_relation_id)
         relation.main_vertical_relation = main_vertical_relation
@@ -80,16 +105,18 @@ def save_main_vertical_relation(request):
 @ajax_required
 @transaction.atomic
 def save_vertical_relation_negation(request):
+    """
+    Add negation to relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'
+    and 'negation_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
+        relation = get_relation_instance(request)
         unified_frame_argument_id = request.POST['unified_frame_argument_id']
         negation_id = request.POST['negation_id']
 
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
         relation.negation_id = negation_id
         relation.negation_argument_id = unified_frame_argument_id
 
@@ -103,14 +130,14 @@ def save_vertical_relation_negation(request):
 @ajax_required
 @transaction.atomic
 def remove_vertical_relation_negation(request):
+    """
+    Remove negation from relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
-
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
+        relation = get_relation_instance(request)
         relation.negation = None
         relation.negation_argument = None
         relation.save()
@@ -120,19 +147,38 @@ def remove_vertical_relation_negation(request):
     return JsonResponse({})
 
 
+def get_relation_instance(request):
+    """
+    Utility method responsible for retrieving relation instance based on request parameters.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: relation instance
+    """
+    source_unified_frame_id = request.POST['source_unified_frame_id']
+    target_unified_frame_id = request.POST['target_unified_frame_id']
+    vertical_relation_id = request.POST['vertical_relation_id']
+    relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
+                                                        target_unified_frame_id=target_unified_frame_id,
+                                                        main_vertical_relation_id=vertical_relation_id)
+    return relation
+
+
 @ajax_required
 @transaction.atomic
 def save_subrelation(request):
+    """
+    Add subrelation to relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    As well as 'subrelation_instance_id' and 'temporal_vertical_relation_id' that represents subrelation instance.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
+        relation = get_relation_instance(request)
+
         subrelation_instance_id = request.POST['subrelation_instance_id']
         temporal_vertical_relation_id = request.POST['temporal_vertical_relation_id']
 
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
         relation.subrelation_id = subrelation_instance_id
         relation.temporal_vertical_relation_for_subrelation_id = temporal_vertical_relation_id
         relation.save()
@@ -145,14 +191,15 @@ def save_subrelation(request):
 @ajax_required
 @transaction.atomic
 def remove_subrelation(request):
+    """
+    Remove subrelation from relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
+        relation = get_relation_instance(request)
 
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
         relation.subrelation = None
         relation.temporal_vertical_relation_for_subrelation = None
         relation.save()
@@ -165,15 +212,16 @@ def remove_subrelation(request):
 @ajax_required
 @transaction.atomic
 def save_iter_relation(request):
+    """
+    Add subrelation to relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    As well as 'subrelation_instance_id' and 'temporal_vertical_relation_id' that represents subrelation instance.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
+        relation = get_relation_instance(request)
         temporal_vertical_relation_id = request.POST['temporal_vertical_relation_id']
-
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
         relation.iter_temporal_vertical_relation_id = temporal_vertical_relation_id
         relation.save()
 
@@ -185,14 +233,14 @@ def save_iter_relation(request):
 @ajax_required
 @transaction.atomic
 def remove_iter_relation(request):
+    """
+    Remove iteration relation from the relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        vertical_relation_id = request.POST['vertical_relation_id']
-
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id,
-                                                            main_vertical_relation_id=vertical_relation_id)
+        relation = get_relation_instance(request)
         relation.iter_temporal_vertical_relation_id = None
         relation.save()
 
@@ -204,14 +252,20 @@ def remove_iter_relation(request):
 @ajax_required
 @transaction.atomic
 def save_target_relation(request):
+    """
+    Add a target unified frame to the relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
         source_unified_frame_id = request.POST['source_unified_frame_id']
         target_unified_frame_id = request.POST['target_unified_frame_id']
         main_vertical_relation_id = request.POST['vertical_relation_id']
 
         relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                             target_unified_frame=None,
-                                                             main_vertical_relation_id=main_vertical_relation_id)
+                                                            target_unified_frame=None,
+                                                            main_vertical_relation_id=main_vertical_relation_id)
         relation.target_unified_frame_id = target_unified_frame_id
         relation.save()
 
@@ -228,15 +282,17 @@ def save_target_relation(request):
                 target_unified_frame_argument = target_unified_frame_arguments[ind]
 
                 unified_frame_argument_slowal_frame_mapping = \
-                    UnifiedFrameArgument2UnifiedFrameArgumentMapping(unified_frame_vertical_relation=relation,
-                                                                     source_unified_agrument=source_unified_frame_argument,
-                                                                     target_unified_agrument=target_unified_frame_argument)
+                    UnifiedFrameArgument2UnifiedFrameArgumentMapping(
+                        unified_frame_vertical_relation=relation,
+                        source_unified_argument=source_unified_frame_argument,
+                        target_unified_argument=target_unified_frame_argument)
                 unified_frame_argument_slowal_frame_mapping.save()
             else:
                 unified_frame_argument_slowal_frame_mapping = \
-                    UnifiedFrameArgument2UnifiedFrameArgumentMapping(unified_frame_vertical_relation=relation,
-                                                                     source_unified_agrument=source_unified_frame_argument,
-                                                                     target_unified_agrument=None)
+                    UnifiedFrameArgument2UnifiedFrameArgumentMapping(
+                        unified_frame_vertical_relation=relation,
+                        source_unified_argument=source_unified_frame_argument,
+                        target_unified_argument=None)
                 unified_frame_argument_slowal_frame_mapping.save()
 
         return JsonResponse({'vertical_relation': get_vertical_relation(relation.id)})
@@ -247,14 +303,14 @@ def save_target_relation(request):
 @ajax_required
 @transaction.atomic
 def remove_target_relation(request):
+    """
+    Remove target unified frame from the relation instance.
+    The request has to contain 'source_unified_frame_id', 'vertical_relation_id', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
-        source_unified_frame_id = request.POST['source_unified_frame_id']
-        target_unified_frame_id = request.POST['target_unified_frame_id']
-        main_vertical_relation_id = request.POST['vertical_relation_id']
-
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame=target_unified_frame_id,
-                                                            main_vertical_relation_id=main_vertical_relation_id)
+        relation = get_relation_instance(request)
 
         conflict_subrelations = UnifiedFrameVerticalRelation.objects.filter(subrelation=relation)
         if not conflict_subrelations.exists():
@@ -263,13 +319,17 @@ def remove_target_relation(request):
             relation.subrelation = None
             relation.temporal_vertical_relation_for_subrelation = None
             relation.iter_temporal_vertical_relation = None
-            UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(unified_frame_vertical_relation=relation).delete()
+            UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(
+                unified_frame_vertical_relation=relation).delete()
             relation.save()
 
             return JsonResponse({'vertical_relation': get_vertical_relation(relation.id), 'succ': True})
         else:
             conflict_subrelation = conflict_subrelations.all()[0]
-            return JsonResponse({'vertical_relation': get_vertical_relation(relation.id), 'succ': False, 'error': 'Nie można usunąć relacji docelowej, ponieważ pozostaje ona w zależności podrelacji do: ' + str(conflict_subrelation)})
+            return JsonResponse({'vertical_relation': get_vertical_relation(relation.id), 'succ': False,
+                                 'error': 'Nie można usunąć relacji docelowej, '
+                                          'ponieważ pozostaje ona w zależności podrelacji do: ' + str(
+                                     conflict_subrelation)})
 
     return JsonResponse({})
 
@@ -277,13 +337,20 @@ def remove_target_relation(request):
 @ajax_required
 @transaction.atomic
 def save_temporal_vertical_relation(request):
+    """
+    Add a list of temporal relation types to the relation instance.
+    The request has to contain 'source_unified_frame_id', 'temporal_vertical_relation_ids', 'target_unified_frame_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
         source_unified_frame_id = request.POST['source_unified_frame_id']
         target_unified_frame_id = request.POST['target_unified_frame_id']
         temporal_vertical_relation_ids = json.loads(request.POST['temporal_vertical_relation_ids'])
 
-        relation = UnifiedFrameVerticalRelation.objects.get(source_unified_frame_id=source_unified_frame_id,
-                                                            target_unified_frame_id=target_unified_frame_id if target_unified_frame_id else None)
+        relation = UnifiedFrameVerticalRelation.objects.get(
+            source_unified_frame_id=source_unified_frame_id,
+            target_unified_frame_id=target_unified_frame_id if target_unified_frame_id else None)
 
         relation.temporal_vertical_relation.clear()
         for temporal_vertical_relation_id in temporal_vertical_relation_ids:
@@ -300,6 +367,12 @@ def save_temporal_vertical_relation(request):
 @ajax_required
 @transaction.atomic
 def load_vertical_relation(request):
+    """
+    Return relation instances information.
+    The request has to contain 'vertical_relation_id'.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
         vertical_relation_id = request.POST['vertical_relation_id']
         relation = get_vertical_relation(vertical_relation_id)
@@ -309,6 +382,11 @@ def load_vertical_relation(request):
 
 
 def relation2dict(vertical_relation):
+    """
+    Converts a vertical_relation object to the dict representation.
+    :param vertical_relation: vertical_relation object
+    :return: json representation of vertical_relation object
+    """
     return {
         'id': vertical_relation.id,
         'negation': {
@@ -319,8 +397,10 @@ def relation2dict(vertical_relation):
             'id': vertical_relation.negation_argument.id,
             'role': vertical_relation.negation_argument.role.role.role,
         } if vertical_relation.negation_argument else None,
-        'source_unified_frame': unified_frame_2_dict(vertical_relation.source_unified_frame) if vertical_relation.source_unified_frame else None,
-        'target_unified_frame': unified_frame_2_dict(vertical_relation.target_unified_frame) if vertical_relation.target_unified_frame else None,
+        'source_unified_frame': unified_frame_2_dict(
+            vertical_relation.source_unified_frame) if vertical_relation.source_unified_frame else None,
+        'target_unified_frame': unified_frame_2_dict(
+            vertical_relation.target_unified_frame) if vertical_relation.target_unified_frame else None,
         'main_vertical_relation': {
             'id': vertical_relation.main_vertical_relation.id,
             'name': vertical_relation.main_vertical_relation.name,
@@ -328,7 +408,9 @@ def relation2dict(vertical_relation):
         'temporal_vertical_relation': [{
             'id': temporal_relation.id,
             'name': temporal_relation.name,
-        } for temporal_relation in vertical_relation.temporal_vertical_relation.all()] if vertical_relation.temporal_vertical_relation else None,
+        } for temporal_relation in
+            vertical_relation.temporal_vertical_relation.all()]
+        if vertical_relation.temporal_vertical_relation else None,
         'subrelation': relation2dict(vertical_relation.subrelation) if vertical_relation.subrelation else None,
         'temporal_vertical_relation_for_subrelation': {
             'id': vertical_relation.temporal_vertical_relation_for_subrelation.id,
@@ -339,9 +421,13 @@ def relation2dict(vertical_relation):
             'name': vertical_relation.iter_temporal_vertical_relation.name,
         } if vertical_relation.iter_temporal_vertical_relation else None,
         'unified_frame_arguments_mapping': [{
-            'source_unified_agrument_id': arguments_mapping.source_unified_agrument.id if arguments_mapping.source_unified_agrument else None,
-            'target_unified_agrument_id': arguments_mapping.target_unified_agrument.id if arguments_mapping.target_unified_agrument else None,
-        } for arguments_mapping in vertical_relation.unified_frame_arguments_mapping.all()] if vertical_relation.unified_frame_arguments_mapping else None,
+            'source_unified_argument_id':
+                arguments_mapping.source_unified_argument.id if arguments_mapping.source_unified_argument else None,
+            'target_unified_argument_id':
+                arguments_mapping.target_unified_argument.id if arguments_mapping.target_unified_argument else None,
+        } for arguments_mapping in
+            vertical_relation.unified_frame_arguments_mapping.all()] if
+        vertical_relation.unified_frame_arguments_mapping else None,
 
     }
 
@@ -355,9 +441,16 @@ def get_vertical_relation(vertical_relation_id):
 @ajax_required
 @transaction.atomic
 def remove_vertical_relation(request):
+    """
+    Remove whole relation instance.
+    The request has to contain 'vertical_relation_id'.
+    :param request: http request
+    :return: empty json
+    """
     if request.method == 'POST':
         vertical_relation_id = request.POST['vertical_relation_id']
-        UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(unified_frame_vertical_relation_id=vertical_relation_id).delete()
+        UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(
+            unified_frame_vertical_relation_id=vertical_relation_id).delete()
         relation = UnifiedFrameVerticalRelation.objects.get(id=vertical_relation_id)
         source_unified_frame_id = relation.source_unified_frame.id
         relation.delete()
@@ -375,6 +468,12 @@ def remove_vertical_relation(request):
 @ajax_required
 @transaction.atomic
 def change_argument_mapping(request):
+    """
+    Swap two target frame argument mapping.
+    The request has to contain 'vertical_relation_id' and 'selected_arguments' that represents arguments to swap.
+    :param request: http request
+    :return: json with current relation instance ('vertical_relation' field')
+    """
     if request.method == 'POST':
         vertical_relation_id = request.POST['vertical_relation_id']
         slowal_frame_selected_arguments = json.loads(request.POST['selected_arguments'])
@@ -389,31 +488,32 @@ def change_argument_mapping(request):
 
         unified_frame_argument_mapping1f = UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(
             unified_frame_vertical_relation=relation,
-            source_unified_agrument_id=arg1_unified_frame_argument_id)
+            source_unified_argument_id=arg1_unified_frame_argument_id)
         unified_frame_argument_mapping2f = UnifiedFrameArgument2UnifiedFrameArgumentMapping.objects.filter(
             unified_frame_vertical_relation=relation,
-            source_unified_agrument_id=arg2_unified_frame_argument_id)
+            source_unified_argument_id=arg2_unified_frame_argument_id)
 
-        unified_frame_argument_mapping1 = unified_frame_argument_mapping1f[0] if unified_frame_argument_mapping1f and unified_frame_argument_mapping1f.exists() else None
-        unified_frame_argument_mapping2 = unified_frame_argument_mapping2f[0] if unified_frame_argument_mapping2f and unified_frame_argument_mapping2f.exists() else None
+        unified_frame_argument_mapping1 = unified_frame_argument_mapping1f[
+            0] if unified_frame_argument_mapping1f and unified_frame_argument_mapping1f.exists() else None
+        unified_frame_argument_mapping2 = unified_frame_argument_mapping2f[
+            0] if unified_frame_argument_mapping2f and unified_frame_argument_mapping2f.exists() else None
 
         if unified_frame_argument_mapping1 is not None and unified_frame_argument_mapping2 is not None:
             # mamy oba argumenty, zamieniamy miescami
-            unified_frame_argument_mapping1.target_unified_agrument_id = arg2_id if arg2_id >= 0 else None
-            unified_frame_argument_mapping2.target_unified_agrument_id = arg1_id if arg1_id >= 0 else None
+            unified_frame_argument_mapping1.target_unified_argument_id = arg2_id if arg2_id >= 0 else None
+            unified_frame_argument_mapping2.target_unified_argument_id = arg1_id if arg1_id >= 0 else None
             unified_frame_argument_mapping1.save()
             unified_frame_argument_mapping2.save()
         elif unified_frame_argument_mapping1 is not None and unified_frame_argument_mapping2 is None:
             # mamy lewy argument, prawy jest Empty
-            unified_frame_argument_mapping1.target_unified_agrument_id = arg2_id if arg2_id >= 0 else None
+            unified_frame_argument_mapping1.target_unified_argument_id = arg2_id if arg2_id >= 0 else None
             unified_frame_argument_mapping1.save()
         elif unified_frame_argument_mapping1 is None and unified_frame_argument_mapping2 is not None:
             # mamy prawy argument, lewy jest Empty
-            unified_frame_argument_mapping2.target_unified_agrument_id = arg1_id if arg1_id >= 0 else None
+            unified_frame_argument_mapping2.target_unified_argument_id = arg1_id if arg1_id >= 0 else None
             unified_frame_argument_mapping2.save()
 
         relation = get_vertical_relation(vertical_relation_id)
         return JsonResponse({'vertical_relation': relation})
 
     return JsonResponse({})
-