docs: def parse_text( self, text, **kwargs ):
          ''' Parses given text with Maltparser. 
          
              As a result of parsing, the input Text object will obtain a new 
              layer named LAYER_CONLL,  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;
              
              return_type : string
                  If return_type=="text" (Default), 
                      returns the input Text object;
                  If return_type=="conll", 
                      returns Maltparser's results as list of CONLL format strings, 
                      each element in the list corresponding to one line in 
                      MaltParser'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_CONLL ) 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:
                 maltparser_support.align_CONLL_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:
          augment_words    = False
          all_return_types = ["text", "conll", "trees", "dep_graphs"]
          return_type      = all_return_types[0]
          for argName, argVal in kwargs.items():
              if argName == '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)
          
          # b) process:
          #  If text has not been morphologically analysed yet, add the 
          #  morphological analysis
          if not text.is_tagged(ANALYSIS):
              text.tag_analysis()
          # Obtain CONLL formatted version of the text
          textConllStr = convert_text_to_CONLL( text, self.feature_generator )
  
          # Execute MaltParser and get results as CONLL formatted string
          resultsConllStr = \
              _executeMaltparser( textConllStr, self.maltparser_dir, \
                                                self.maltparser_jar, \
                                                self.model_name )
          # Align the results with the initial text
          alignments = \
              align_CONLL_with_Text( resultsConllStr, text, self.feature_generator, **kwargs )
          alignments = \
              normalise_alignments( alignments, data_type=CONLL_DATA, **kwargs )
          
          # c) attach & return results
          text[LAYER_CONLL] = alignments
          if augment_words:
              # Augment the input text with the dependency relation information 
              # obtained from MaltParser 
              # (!) Note: this will be deprecated in the future
              augmentTextWithCONLLstr( resultsConllStr, text )
          if return_type   == "conll":
              return resultsConllStr
          elif return_type == "trees":
              return build_trees_from_text( text, layer=LAYER_CONLL, **kwargs )
          elif return_type == "dep_graphs":
              trees = build_trees_from_text( text, layer=LAYER_CONLL, **kwargs )
              graphs = [tree.as_dependencygraph() for tree in trees]
              return graphs
              # An alternative:
              # Return DependencyGraphs
              #from nltk.parse.dependencygraph import DependencyGraph
              #all_trees = []
              #for tree_str in ("\n".join(resultsConllStr)).split('\n\n'):
              #    t = DependencyGraph(tree_str)
              #    all_trees.append(t)
              #return all_trees
          else:
              return text