

'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_convbert import ConvBertTokenizer


_snake_case         =  logging.get_logger(__name__)

_snake_case         =  {'''vocab_file''': '''vocab.txt'''}

_snake_case         =  {
    '''vocab_file''': {
        '''YituTech/conv-bert-base''': '''https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt''',
        '''YituTech/conv-bert-medium-small''': (
            '''https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt'''
        ),
        '''YituTech/conv-bert-small''': '''https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt''',
    }
}

_snake_case         =  {
    '''YituTech/conv-bert-base''': 512,
    '''YituTech/conv-bert-medium-small''': 512,
    '''YituTech/conv-bert-small''': 512,
}


_snake_case         =  {
    '''YituTech/conv-bert-base''': {'''do_lower_case''': True},
    '''YituTech/conv-bert-medium-small''': {'''do_lower_case''': True},
    '''YituTech/conv-bert-small''': {'''do_lower_case''': True},
}


class        a__  (							a__  ):
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							VOCAB_FILES_NAMES
   _SCREAMING_SNAKE_CASE   :					str     	=							PRETRAINED_VOCAB_FILES_MAP
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							PRETRAINED_INIT_CONFIGURATION
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _SCREAMING_SNAKE_CASE   :					List[Any]     	=							ConvBertTokenizer


   def __init__(			self      ,    _UpperCamelCase=None      ,    _UpperCamelCase=None      ,    _UpperCamelCase=True      ,    _UpperCamelCase="[UNK]"      ,    _UpperCamelCase="[SEP]"      ,    _UpperCamelCase="[PAD]"      ,    _UpperCamelCase="[CLS]"      ,    _UpperCamelCase="[MASK]"      ,    _UpperCamelCase=True      ,    _UpperCamelCase=None      ,    **_UpperCamelCase      ,    ):





      """simple docstring"""





      super().__init__(
          lowerCAmelCase__      ,    tokenizer_file=lowerCAmelCase__      ,    do_lower_case=lowerCAmelCase__      ,    unk_token=lowerCAmelCase__      ,    sep_token=lowerCAmelCase__      ,    pad_token=lowerCAmelCase__      ,    cls_token=lowerCAmelCase__      ,    mask_token=lowerCAmelCase__      ,    tokenize_chinese_chars=lowerCAmelCase__      ,    strip_accents=lowerCAmelCase__      ,    **lowerCAmelCase__      ,    )

      _lowercase      :				Optional[int]      					=       json.loads(self.backend_tokenizer.normalizer.__getstate__()  )
      if (
          normalizer_state.get("lowercase"      ,    lowerCAmelCase__  ) != do_lower_case
          or normalizer_state.get("strip_accents"      ,    lowerCAmelCase__  ) != strip_accents
          or normalizer_state.get("handle_chinese_chars"      ,    lowerCAmelCase__  ) != tokenize_chinese_chars
      ):
         _lowercase      :				int      					=       getattr(lowerCAmelCase__      ,    normalizer_state.pop("type"  )  )
         _lowercase      :				Tuple      					=       do_lower_case
         _lowercase      :				Optional[Any]      					=       strip_accents
         _lowercase      :				Optional[int]      					=       tokenize_chinese_chars
         _lowercase      :				Tuple      					=       normalizer_class(**lowerCAmelCase__  )

      _lowercase      :				str      					=       do_lower_case


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase=None  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       [self.cls_token_id] + token_ids_a + [self.sep_token_id]

      if token_ids_a:
         output += token_ids_a + [self.sep_token_id]

      return output


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase = None  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       [self.sep_token_id]
      _lowercase      :				Any      					=       [self.cls_token_id]
      if token_ids_a is None:
         return len(cls + token_ids_a + sep  ) * [0]
      return len(cls + token_ids_a + sep  ) * [0] + len(token_ids_a + sep  ) * [1]






   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase = None  ):





      """simple docstring"""





      _lowercase      :				str      					=       self._tokenizer.model.save(lowerCAmelCase__      ,    name=lowerCAmelCase__  )
      return tuple(lowerCAmelCase__  )









'''simple docstring'''
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer


class        a__  (							lowerCamelCase_  ):
   _SCREAMING_SNAKE_CASE   :					int     	=							'Wav2Vec2FeatureExtractor'
   _SCREAMING_SNAKE_CASE   :					List[str]     	=							'AutoTokenizer'


   def __init__(			self      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      super().__init__(_UpperCamelCase      ,    _UpperCamelCase  )
      _lowercase      :				List[Any]      					=       self.feature_extractor
      _lowercase      :				Optional[Any]      					=       False


   @classmethod
   def 						_lowerCamelCase       (			cls      ,    _UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      try:
         return super().from_pretrained(_UpperCamelCase      ,    **_UpperCamelCase  )
      except OSError:
         warnings.warn(
             f'''Loading a tokenizer inside {cls.__name__} from a config that does not'''
             " include a `tokenizer_class` attribute is deprecated and will be "
             "removed in v5. Please add `'tokenizer_class': 'Wav2Vec2CTCTokenizer'`"
             " attribute to either your `config.json` or `tokenizer_config.json` "
             "file to suppress this warning: "      ,    _UpperCamelCase      ,    )

         _lowercase      :				Dict      					=       WavaVecaFeatureExtractor.from_pretrained(_UpperCamelCase      ,    **_UpperCamelCase  )
         _lowercase      :				str      					=       WavaVecaCTCTokenizer.from_pretrained(_UpperCamelCase      ,    **_UpperCamelCase  )

         return cls(feature_extractor=_UpperCamelCase      ,    tokenizer=_UpperCamelCase  )


   def __call__(			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      if self._in_target_context_manager:
         return self.current_processor(*_UpperCamelCase      ,    **_UpperCamelCase  )

      if "raw_speech" in kwargs:
         warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."  )
         _lowercase      :				int      					=       kwargs.pop("raw_speech"  )
      else:
         _lowercase      :				List[Any]      					=       kwargs.pop("audio"      ,    _UpperCamelCase  )
      _lowercase      :				List[Any]      					=       kwargs.pop("sampling_rate"      ,    _UpperCamelCase  )
      _lowercase      :				Union[str, Any]      					=       kwargs.pop("text"      ,    _UpperCamelCase  )
      if len(_UpperCamelCase  ) > 0:
         _lowercase      :				int      					=       args[0]
         _lowercase      :				Any      					=       args[1:]

      if audio is None and text is None:
         raise ValueError("You need to specify either an `audio` or `text` input to process."  )

      if audio is not None:
         _lowercase      :				Dict      					=       self.feature_extractor(_UpperCamelCase      ,    *_UpperCamelCase      ,    sampling_rate=_UpperCamelCase      ,    **_UpperCamelCase  )
      if text is not None:
         _lowercase      :				Union[str, Any]      					=       self.tokenizer(_UpperCamelCase      ,    **_UpperCamelCase  )

      if text is None:
         return inputs
      elif audio is None:
         return encodings
      else:
         _lowercase      :				int      					=       encodings["input_ids"]
         return inputs


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      if self._in_target_context_manager:
         return self.current_processor.pad(*_UpperCamelCase      ,    **_UpperCamelCase  )

      _lowercase      :				List[Any]      					=       kwargs.pop("input_features"      ,    _UpperCamelCase  )
      _lowercase      :				Any      					=       kwargs.pop("labels"      ,    _UpperCamelCase  )
      if len(_UpperCamelCase  ) > 0:
         _lowercase      :				Any      					=       args[0]
         _lowercase      :				Any      					=       args[1:]

      if input_features is not None:
         _lowercase      :				Any      					=       self.feature_extractor.pad(_UpperCamelCase      ,    *_UpperCamelCase      ,    **_UpperCamelCase  )
      if labels is not None:
         _lowercase      :				int      					=       self.tokenizer.pad(_UpperCamelCase      ,    **_UpperCamelCase  )

      if labels is None:
         return input_features
      elif input_features is None:
         return labels
      else:
         _lowercase      :				Optional[Any]      					=       labels["input_ids"]
         return input_features


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.tokenizer.batch_decode(*_UpperCamelCase      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    *_UpperCamelCase      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return self.tokenizer.decode(*_UpperCamelCase      ,    **_UpperCamelCase  )






   @contextmanager
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      warnings.warn(
          "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
          "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
          "your audio inputs, or in a separate call."  )
      _lowercase      :				Optional[Any]      					=       True
      _lowercase      :				Dict      					=       self.tokenizer
      yield
      _lowercase      :				List[str]      					=       self.feature_extractor
      _lowercase      :				List[str]      					=       False






