docs: def tokenize(self, sentence,
                   normalized=True,
                   is_feature=False,
                   is_surface=False,
                   return_list=False,
                   func_normalizer=normalize_text):
          # type: (text_type, bool, bool, bool, bool, Callable[[str], str])->Union[List[str], TokenizedSenetence]
          """* What you can do
          - Call mecab tokenizer, and return tokenized objects
  
          """
          if six.PY2 and isinstance(sentence, str):
              sentence = sentence.decode(self.string_encoding)
          else:
              pass
  
          # decide normalization function depending on dictType
          if func_normalizer is None and self._dictType == 'neologd' and is_neologdn_valid:
              normalized_sentence = neologdn.normalize(sentence)
          elif func_normalizer is None and self._dictType == 'neologd' and is_neologdn_valid == False:
              raise Exception("You could not call neologd dictionary bacause you do NOT install the package neologdn.")
          elif func_normalizer == normalize_text:
              normalized_sentence = normalize_text(sentence, dictionary_mode=self._dictType)
          elif func_normalizer is None:
              normalized_sentence = sentence
          else:
              normalized_sentence = func_normalizer(sentence)
  
          # don't delete this variable. The variable "encoded_text" protects sentence from deleting
          if six.PY2:
              encoded_text = normalized_sentence.encode(self.string_encoding)
          else:
              encoded_text = normalized_sentence
  
          if six.PY2:
              tokenized_objects = []
              node = self.mecabObj.parseToNode(encoded_text)
              node = node.next
              while node.next is not None:
                  word_surface = node.surface.decode(self.string_encoding)
  
                  tuple_pos, word_stem = self.__feature_parser(node.feature.decode(self.string_encoding), word_surface)
  
                  tokenized_obj = TokenizedResult(
                      node_obj=node,
                      tuple_pos=tuple_pos,
                      word_stem=word_stem,
                      word_surface=word_surface,
                      is_feature=is_feature,
                      is_surface=is_surface
                  )
                  tokenized_objects.append(tokenized_obj)
                  node = node.next
  
              tokenized_sentence = TokenizedSenetence(
                  sentence=sentence,
                  tokenized_objects=tokenized_objects)
          else:
              parsed_result = self.mecabObj.parse(encoded_text)
              tokenized_objects = self.__postprocess_analyzed_result(
                  string_mecab_parsed_result=parsed_result,
                  is_feature=is_feature,
                  is_surface=is_surface
              )
              tokenized_sentence = TokenizedSenetence(
                  sentence=sentence,
                  tokenized_objects=tokenized_objects
              )  # type: TokenizedSenetence
  
          if return_list:
              return tokenized_sentence.convert_list_object()
          else:
              return tokenized_sentence