



import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin







class       _snake_case				(     __snake_case ):






   '''simple docstring'''






   A__      : Union[str, Any]       =						"AutoFeatureExtractor"
   A__      : List[str]       =						"Speech2Text2Tokenizer"


   def __init__(    self:     Optional[Any]  ,lowerCamelCase_:     int  ,lowerCamelCase_:     Dict							)	->      str:
       super().__init__(lowerCamelCase_  ,lowerCamelCase_							)
       UpperCAmelCase_     :       Tuple  		=					self.feature_extractor
       UpperCAmelCase_     :       Dict  		=					False


   def __call__(    self:     int  ,*lowerCamelCase_:     Any  ,**lowerCamelCase_:     str							)	->      List[str]:
       # For backward compatibility
       if self._in_target_context_manager:
           return self.current_processor(*lowerCamelCase_  ,**lowerCamelCase_							)

       if "raw_speech" in kwargs:
           warnings.warn("""Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."""							)
           UpperCAmelCase_     :       Any  		=					kwargs.pop("""raw_speech"""							)
       else:
           UpperCAmelCase_     :       Optional[int]  		=					kwargs.pop("""audio"""  ,lowerCamelCase_							)
       UpperCAmelCase_     :       Optional[int]  		=					kwargs.pop("""sampling_rate"""  ,lowerCamelCase_							)
       UpperCAmelCase_     :       Any  		=					kwargs.pop("""text"""  ,lowerCamelCase_							)
       if len(lowerCamelCase_							) > 0:
           UpperCAmelCase_     :       Union[str, Any]  		=					args[0]
           UpperCAmelCase_     :       Tuple  		=					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:
           UpperCAmelCase_     :       Dict  		=					self.feature_extractor(lowerCamelCase_  ,*lowerCamelCase_  ,sampling_rate=lowerCamelCase_  ,**lowerCamelCase_							)
       if text is not None:
           UpperCAmelCase_     :       int  		=					self.tokenizer(lowerCamelCase_  ,**lowerCamelCase_							)

       if text is None:
           return inputs
       elif audio is None:
           return encodings
       else:
           UpperCAmelCase_     :       Optional[Any]  		=					encodings["""input_ids"""]
           return inputs


   def       A__    (    self:     Optional[int]  ,*lowerCamelCase_:     List[str]  ,**lowerCamelCase_:     Union[str, Any]							)	->      Optional[Any]:
       return self.tokenizer.batch_decode(*lowerCamelCase_  ,**lowerCamelCase_							)


   def       A__    (    self:     str  ,*lowerCamelCase_:     Any  ,**lowerCamelCase_:     List[Any]							)	->      List[str]:
       return self.tokenizer.decode(*lowerCamelCase_  ,**lowerCamelCase_							)






   @contextmanager
   def       A__    (    self:     Dict							)	->      Optional[Any]:
       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."""							)
       UpperCAmelCase_     :       int  		=					True
       UpperCAmelCase_     :       Tuple  		=					self.tokenizer
       yield
       UpperCAmelCase_     :       Tuple  		=					self.feature_extractor
       UpperCAmelCase_     :       Dict  		=					False



"""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_splinter import SplinterTokenizer


SCREAMING_SNAKE_CASE_  :      str							=      logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_  :      List[Any]							=      {'''vocab_file''': '''vocab.txt'''}

SCREAMING_SNAKE_CASE_  :      int							=      {
    '''vocab_file''': {
        '''tau/splinter-base''': '''https://huggingface.co/tau/splinter-base/resolve/main/vocab.txt''',
        '''tau/splinter-base-qass''': '''https://huggingface.co/tau/splinter-base-qass/resolve/main/vocab.txt''',
        '''tau/splinter-large''': '''https://huggingface.co/tau/splinter-large/resolve/main/vocab.txt''',
        '''tau/splinter-large-qass''': '''https://huggingface.co/tau/splinter-large-qass/resolve/main/vocab.txt''',
    }
}

SCREAMING_SNAKE_CASE_  :      Union[str, Any]							=      {
    '''tau/splinter-base''': 512,
    '''tau/splinter-base-qass''': 512,
    '''tau/splinter-large''': 512,
    '''tau/splinter-large-qass''': 512,
}

SCREAMING_SNAKE_CASE_  :      List[Any]							=      {
    '''tau/splinter-base''': {'''do_lower_case''': False},
    '''tau/splinter-base-qass''': {'''do_lower_case''': False},
    '''tau/splinter-large''': {'''do_lower_case''': False},
    '''tau/splinter-large-qass''': {'''do_lower_case''': False},
}


class 		_A							(      __a       ):
      __a             =						VOCAB_FILES_NAMES
      __a             =						PRETRAINED_VOCAB_FILES_MAP
      __a             =						PRETRAINED_INIT_CONFIGURATION
      __a             =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      __a             =						SplinterTokenizer





      def __init__(	self     ,    SCREAMING_SNAKE_CASE__=None     ,    SCREAMING_SNAKE_CASE__=None     ,    SCREAMING_SNAKE_CASE__=True     ,    SCREAMING_SNAKE_CASE__="[UNK]"     ,    SCREAMING_SNAKE_CASE__="[SEP]"     ,    SCREAMING_SNAKE_CASE__="[PAD]"     ,    SCREAMING_SNAKE_CASE__="[CLS]"     ,    SCREAMING_SNAKE_CASE__="[MASK]"     ,    SCREAMING_SNAKE_CASE__="[QUESTION]"     ,    SCREAMING_SNAKE_CASE__=True     ,    SCREAMING_SNAKE_CASE__=None     ,    **SCREAMING_SNAKE_CASE__     ,    ) ->       Optional[Any]:
         super().__init__(
             SCREAMING_SNAKE_CASE__     ,    tokenizer_file=SCREAMING_SNAKE_CASE__     ,    do_lower_case=SCREAMING_SNAKE_CASE__     ,    unk_token=SCREAMING_SNAKE_CASE__     ,    sep_token=SCREAMING_SNAKE_CASE__     ,    pad_token=SCREAMING_SNAKE_CASE__     ,    cls_token=SCREAMING_SNAKE_CASE__     ,    mask_token=SCREAMING_SNAKE_CASE__     ,    tokenize_chinese_chars=SCREAMING_SNAKE_CASE__     ,    strip_accents=SCREAMING_SNAKE_CASE__     ,    additional_special_tokens=(question_token,)     ,    **SCREAMING_SNAKE_CASE__     ,    )

         lowerCamelCase__						       =      json.loads(self.backend_tokenizer.normalizer.__getstate__()		)
         if (
             pre_tok_state.get("lowercase"     ,    SCREAMING_SNAKE_CASE__		) != do_lower_case
             or pre_tok_state.get("strip_accents"     ,    SCREAMING_SNAKE_CASE__		) != strip_accents
         ):
            lowerCamelCase__						       =      getattr(SCREAMING_SNAKE_CASE__     ,    pre_tok_state.pop("type"		)		)
            lowerCamelCase__						       =      do_lower_case
            lowerCamelCase__						       =      strip_accents
            lowerCamelCase__						       =      pre_tok_class(**SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      do_lower_case





      @property
      def        _lowerCamelCase	(	self		) ->       Optional[Any]:
         return self.convert_tokens_to_ids(self.question_token		)





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__ = None		) ->       List[int]:
         if token_ids_a is None:
            return [self.cls_token_id] + token_ids_a + [self.sep_token_id]

         lowerCamelCase__						       =      [self.cls_token_id]
         lowerCamelCase__						       =      [self.sep_token_id]
         lowerCamelCase__						       =      [self.question_token_id] + [self.convert_tokens_to_ids("."		)]
         if self.padding_side == "right":
            # Input is question-then-context
            return cls + token_ids_a + question_suffix + sep + token_ids_a + sep
         else:
            # Input is context-then-question
            return cls + token_ids_a + sep + token_ids_a + question_suffix + sep





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__ = None		) ->       List[int]:
         lowerCamelCase__						       =      [self.sep_token_id]
         lowerCamelCase__						       =      [self.cls_token_id]
         lowerCamelCase__						       =      [self.question_token_id] + [self.convert_tokens_to_ids("."		)]
         if token_ids_a is None:
            return len(cls + token_ids_a + sep		) * [0]

         if self.padding_side == "right":
            # Input is question-then-context
            return len(cls + token_ids_a + question_suffix + sep		) * [0] + len(token_ids_a + sep		) * [1]
         else:
            # Input is context-then-question
            return len(cls + token_ids_a + sep		) * [0] + len(token_ids_a + question_suffix + sep		) * [1]





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__ = None		) ->       Tuple[str]:
         lowerCamelCase__						       =      self._tokenizer.model.save(SCREAMING_SNAKE_CASE__     ,    name=SCREAMING_SNAKE_CASE__		)
         return tuple(SCREAMING_SNAKE_CASE__		)




