docs: def parse_text(self, text, **kwargs):
          """ Parses given text with VISLCG3 based syntactic analyzer. 
          
              As a result of parsing, the input Text object will obtain a new 
              layer named LAYER_VISLCG3,  which  contains  a  list  of  dicts.
              Each dicts corresponds to analysis of a single word token, and
              has the following attributes (at minimum):
                'start'      -- start index of the word in Text;
                'end'        -- end index of the word in Text;
                'sent_id'    -- index of the sentence in Text, starting from 0;
                'parser_out' -- list of analyses from the output of the 
                                syntactic parser;
                  In the list of analyses, each item has the following structure:
                      [ syntactic_label, index_of_the_head ]
                  *) syntactic_label:
                         surface syntactic label of the word, e.g. '@SUBJ', 
                         '@OBJ', '@ADVL';
                  *) index_of_the_head:
                         index of the head (in the sentence); 
                         -1 if the current token is root;
              
              Parameters
              -----------
              text : estnltk.text.Text
                 The input text that should be analysed for dependency relations;
              
              apply_tag_analysis : bool
                  Specifies whether, in case of a missing morphological ANALYSIS 
                  layer, the text is morphologically analysed and disambiguated
                  via the method *text.tag_analysis*  before  proceeding  with 
                  the syntactic analysis.
                  Note that the syntactic analyser does its own morphological 
                  disambiguation, but results of that disambiguation do not reach 
                  back to the Text object, so the Text object will contain a layer 
                  of ambiguous morphological analyses at the end of the parsing 
                  step;
                  You can use *apply_tag_analysis=True* to ensure that at the 
                  end of the parsing step, the input Text is both morphologically 
                  analysed and disambiguated;
                  Default: False
  
              return_type : string
                  If return_type=="text" (Default), 
                      returns the input Text object;
                  If return_type=="vislcg3", 
                      returns VISLCG3's output: a list of strings, each element in 
                      the list corresponding to a line from VISLCG3's output;
                  If return_type=="trees", 
                      returns all syntactic trees of the text as a list of 
                      EstNLTK's Tree objects (estnltk.syntax.utils.Tree);
                  If return_type=="dep_graphs", 
                      returns all syntactic trees of the text as a list of NLTK's 
                      DependencyGraph objects 
                      (nltk.parse.dependencygraph.DependencyGraph);
                  Regardless the return type, the layer containing dependency syntactic
                  information ( LAYER_VISLCG3 ) will be attached to the text object;
              
              augment_words : bool
                  Specifies whether words in the input Text are to be augmented with 
                  the syntactic information (SYNTAX_LABEL, SYNTAX_HEAD and DEPREL);
                  (!) This functionality is added to achieve a compatibility with the 
                  old way syntactic processing, but it will be likely deprecated in 
                  the future.
                  Default: False
              
              Other arguments are the arguments that can be passed to methods:
                 vislcg3_syntax.process_lines(), 
                 vislcg3_syntax.align_cg3_with_Text(),
                 normalise_alignments()
              
              keep_old : bool
                  Optional argument specifying  whether the old analysis lines 
                  should be preserved after overwriting 'parser_out' with new analysis 
                  lines;
                  If True, each dict will be augmented with key 'init_parser_out' 
                  which contains the initial/old analysis lines;
                  Default:False
              
          """
          # a) get the configuration:
          apply_tag_analysis = False
          augment_words      = False
          all_return_types = ["text","vislcg3","trees","dep_graphs"]
          return_type      = all_return_types[0]
          for argName, argVal in kwargs.items():
              if argName.lower() == 'return_type':
                  if argVal.lower() in all_return_types:
                      return_type = argVal.lower()
                  else:
                      raise Exception(' Unexpected return type: ', argVal)
              elif argName.lower() == 'augment_words':
                  augment_words = bool(argVal)
              elif argName.lower() == 'apply_tag_analysis':
                  apply_tag_analysis = bool(argVal)
          kwargs['split_result']  = True
          kwargs['clean_up']      = True
          kwargs['remove_clo']    = kwargs.get('remove_clo', True)
          kwargs['remove_cap']    = kwargs.get('remove_cap', True)
          kwargs['keep_old']      = kwargs.get('keep_old',  False)
          kwargs['double_quotes'] = 'unesc'
          
          # b) process:
          if apply_tag_analysis:
              text = text.tag_analysis()
          result_lines1 = \
              self.preprocessor.process_Text(text, **kwargs)
          result_lines2 = \
              self.vislcg3_processor.process_lines(result_lines1, **kwargs)
          alignments = \
              align_cg3_with_Text(result_lines2, text, **kwargs)
          alignments = \
              normalise_alignments( alignments, data_type=VISLCG3_DATA, **kwargs )
          
          # c) attach & return results
          text[LAYER_VISLCG3] = alignments
          if augment_words:
              self._augment_text_w_syntactic_info( text, text[LAYER_VISLCG3] )
          if return_type   == "vislcg3":
              return result_lines2
          elif return_type == "trees":
              return build_trees_from_text( text, layer=LAYER_VISLCG3, **kwargs )
          elif return_type == "dep_graphs":
              trees = build_trees_from_text( text, layer=LAYER_VISLCG3, **kwargs )
              graphs = [tree.as_dependencygraph() for tree in trees]
              return graphs
          else:
              return text