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