docs: def process_lines( self, input_lines, **kwargs ):
          ''' Executes the pipeline of subsequent VISL_CG3 commands. The first process
              in pipeline gets input_lines as an input, and each subsequent process gets
              the output of the previous process as an input.
              
              The idea of how to construct the pipeline borrows from:
                https://github.com/estnltk/estnltk/blob/1.4.0/estnltk/syntax/tagger.py
              
              Returns the result of the last process in the pipeline, either as a string 
              or, alternatively, as a list of strings (if split_result == True);
   
              Parameters
              -----------
              input_lines : list of str
                   The input text for the pipeline; Should be in same format as the output
                   of SyntaxPreprocessing;
  
              split_result : bool
                   Optional argument specifying whether the result should be split by 
                   newlines, and returned as a list of strings/lines instead;
                   Default:False
  
              remove_info : bool
                   Optional argument specifying whether the additional information added 
                   during the preprocessing and syntactic processing should be removed
                   from the results;
                   Default:True;
                   The method  cleanup_lines()  will be used for removing additional info,
                   and all the parameters passed to this method will be also forwarded to 
                   the cleanup method;
  
          '''
          split_result_lines = False
          remove_info = True
          for argName, argVal in kwargs.items() :
              if argName in ['split_result_lines', 'split_result'] and argVal in [True, False]:
                 split_result_lines = argVal
              if argName in ['remove_info', 'info_remover', 'clean_up'] and argVal in [True, False]:
                 remove_info = argVal
  
          # 1) Construct the input file for the first process in the pipeline
          temp_input_file = \
              tempfile.NamedTemporaryFile(prefix='vislcg3_in.', mode='w', delete=False)
          temp_input_file.close()
          # We have to open separately here for writing, because Py 2.7 does not support
          # passing parameter   encoding='utf-8'    to the NamedTemporaryFile;
          out_f = codecs.open(temp_input_file.name, mode='w', encoding='utf-8')
          for line in input_lines:
              out_f.write( line.rstrip() )
              out_f.write( '\n' )
          out_f.close()
          # TODO: tempfile is currently used to ensure that the input is in 'utf-8',
          #       but perhaps we can somehow ensure it without using tempfile ??
  
  
          # 2) Dynamically construct the pipeline and open processes
          pipeline = []
          for i in range( len(self.rules_pipeline) ):
              rule_file = self.rules_pipeline[i]
              process_cmd = [self.vislcg_cmd, '-o', '-g', os.path.join(self.rules_dir, rule_file)]
              process = None
              if i == 0:
                 # The first process takes input from the file
                 process_cmd.extend( ['-I', temp_input_file.name] )
                 process = Popen(process_cmd, stdin=PIPE, stdout=PIPE)
              else:
                 # A subsequent process takes output of the last process as an input
                 process = Popen(process_cmd, stdin=pipeline[-1]['process'].stdout, stdout=PIPE)
              # Record the process
              process_dict = {'process':process, 'cmd':process_cmd}
              pipeline.append( process_dict )
          
          # 3) Close all stdout streams, except the last one
          for i in range( len(pipeline) ):
             if i != len(pipeline) - 1:
                pipeline[i]['process'].stdout.close()
  
          # 4) Communicate results form the last item in the pipeline
          result = as_unicode( pipeline[-1]['process'].communicate()[0] )
          pipeline[-1]['process'].stdout.close() # Close the last process
  
          # Clean-up
          # 1) remove temp file
          os.remove(temp_input_file.name)
  
          # 2) remove additional info, if required
          if remove_info:
                result = '\n'.join( cleanup_lines( result.split('\n'), **kwargs ))
  
          return result if not split_result_lines else result.split('\n')