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
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