docs: def get_children( self, **kwargs ):
          ''' Recursively collects and returns all subtrees of given tree (if no 
              arguments are given), or, alternatively, collects and returns subtrees 
              satisfying some specific criteria (pre-specified in the arguments);
              
              Parameters
              -----------
              depth_limit : int
                  Specifies how deep into the subtrees of this tree the search goes;
                  Examples:
                   depth_limit=2 -- children of this node, and also children's
                                    direct children are considered as collectibles;
                   depth_limit=1 -- only children of this node are considered;
                   depth_limit=0 -- the end of search (only this node is considered);
                  Default: unbounded ( the search is not limited by depth )
              
              include_self : bool 
                  Specifies whether this tree should also be included as a collectible
                  subtree. If this tree is includes, it still must satisfy all the 
                  criteria before it is included in the collection;
                  Default: False
              
              sorted : bool
                  Specifies returned trees should be sorted in the ascending order of 
                  word_ids (basically: by the order of words in the text);
                  If sorting is not applied, there is no guarantee that resulting trees
                  follow the order of words in text;
                  Default: False
                  
              Following parameters can be used to set conditions for subtrees:
              -----------------------------------------------------------------
              label : str
                  Syntactic label (e.g. '@SUBJ', '@OBJ' etc.) that the node 
                  must have within its analysis; If the node does not have the
                  label, the node will be discarded;
              
              label_regexp : str
                  A regular expression pattern (as string) describing the 
                  syntactic label (e.g. '@SUBJ', '@OBJ' etc.) that the node 
                  must have within its analysis; 
                  If none of the node's labels matches the pattern, the node
                  will be discarded;
              
              word_template : estnltk.mw_verbs.utils.WordTemplate
                  A WordTemplate describing morphological constraints imposed
                  to the word of the node;
                  If the word's morphological features do not match the template, 
                  the node will be discarded;
              
          '''
          depth_limit  = kwargs.get('depth_limit', 922337203685477580) # Just a nice big number to
                                                                       # assure that by default, 
                                                                       # there is no depth limit ...
          include_self = kwargs.get('include_self', False)
          sorted_by_word_ids = kwargs.get('sorted', False)
          subtrees = []
          if include_self:
              if self._satisfies_conditions( self, **kwargs ):
                  subtrees.append( self )
          if depth_limit >= 1 and self.children:
              # 1) Add children of given tree
              for child in self.children:
                  if self._satisfies_conditions( child, **kwargs ):
                      subtrees.append(child)
              # 2) Collect children of given tree's children
              kwargs['include_self'] = False
              kwargs['depth_limit']  = depth_limit - 1 
              for child in self.children:
                  childs_results = child.get_children( **kwargs )
                  if childs_results:
                      subtrees.extend(childs_results)
          if sorted_by_word_ids:
              # Sort by word_id-s, in ascending order
              subtrees = sorted(subtrees, key=lambda x: x.word_id)
          return subtrees