class_docstr: Constructs a Wav2Vec2PhonemeCTC tokenizer.
  
  This tokenizer inherits from [`PreTrainedTokenizer`] which contains some of the main methods. Users should refer to
  the superclass for more information regarding such methods.
  
  Args:
      vocab_file (`str`):
          File containing the vocabulary.
      bos_token (`str`, *optional*, defaults to `"<s>"`):
          The beginning of sentence token.
      eos_token (`str`, *optional*, defaults to `"</s>"`):
          The end of sentence token.
      unk_token (`str`, *optional*, defaults to `"<unk>"`):
          The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
          token instead.
      pad_token (`str`, *optional*, defaults to `"<pad>"`):
          The token used for padding, for example when batching sequences of different lengths.
      do_phonemize (`bool`, *optional*, defaults to `True`):
          Whether the tokenizer should phonetize the input or not. Only if a sequence of phonemes is passed to the
          tokenizer, `do_phonemize` should be set to `False`.
      phonemizer_lang (`str`, *optional*, defaults to `"en-us"`):
          The language of the phoneme set to which the tokenizer should phonetize the input text to.
      phonemizer_backend (`str`, *optional*. defaults to `"espeak"`):
          The backend phonetization library that shall be used by the phonemizer library. Defaults to `espeak-ng`.
          See the [phonemizer package](https://github.com/bootphon/phonemizer#readme). for more information.
  
      **kwargs
          Additional keyword arguments passed along to [`PreTrainedTokenizer`]
docstr: Converts a connectionist-temporal-classification (CTC) output tokens into a single string.
code: def convert_tokens_to_string(
      self,
      tokens: List[str],
      group_tokens: bool = True,
      spaces_between_special_tokens: bool = False,
      filter_word_delimiter_token: bool = True,
      output_char_offsets: bool = False,
  ) -> str:
      """
      Converts a connectionist-temporal-classification (CTC) output tokens into a single string.
      """
      # group same tokens into non-repeating tokens in CTC style decoding
      if group_tokens:
          chars, char_repetitions = zip(
              *(
                  (token, len(list(group_iter)))
                  for token, group_iter in groupby(tokens)
              )
          )
      else:
          chars = tokens
          char_repetitions = len(tokens) * [1]
  
      # filter self.pad_token which is used as CTC-blank token
      processed_chars = list(
          filter(lambda char: char != self.pad_token, chars)
      )
  
      # also filter self.word_delimiter_token if not not
      if (
          filter_word_delimiter_token
          and self.word_delimiter_token is not None
      ):
          processed_chars = list(
              filter(
                  lambda token: token != self.word_delimiter_token,
                  processed_chars,
              )
          )
  
      # retrieve offsets
      char_offsets = None
      if output_char_offsets:
          word_delimiter_token_for_offsets = (
              self.word_delimiter_token
              if filter_word_delimiter_token is True
              else None
          )
          char_offsets = self._compute_offsets(
              char_repetitions,
              chars,
              self.pad_token,
              word_delimiter_token=word_delimiter_token_for_offsets,
          )
  
          if len(char_offsets) != len(processed_chars):
              raise ValueError(
                  f"`char_offsets`: {char_offsets} and `processed_tokens`: {processed_chars}"
                  " have to be of the same length, but are: `len(offsets)`: "
                  f"{len(char_offsets)} and `len(processed_tokens)`: {len(processed_chars)}"
              )
  
          # set tokens to correct processed token
          for i, char in enumerate(processed_chars):
              char_offsets[i]["char"] = char
  
      string = " ".join(processed_chars).strip()
  
      return {"text": string, "char_offsets": char_offsets}
  
imports: import json
  import os
  import sys
  from dataclasses import dataclass
  from itertools import groupby
  from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
  import numpy
  from ...tokenization_utils import PreTrainedTokenizer, _insert_one_token_to_ordered_list
  from ...tokenization_utils_base import AddedToken
  from ...utils import ModelOutput, is_flax_available, is_tf_available, is_torch_available, logging, requires_backends, to_py_obj
label_desc: Use image node_id 18 for calling the Wav2Vec2PhonemeCTCTokenizer obj's underlying member method code with example usage: obj.convert_tokens_to_string(tokens, group_tokens, spaces_between_special_tokens, filter_word_delimiter_token, output_char_offsets) and returns: dict