



"""simple docstring"""







import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A     =      logging.get_logger(__name__)

A     =      {
    '''facebook/hubert-base-ls960''': '''https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json''',
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}






class   UpperCAmelCase__		(   __a  ):
		lowerCAmelCase_							:						str							=  """hubert"""



		def __init__(			self	:     List[Any]   ,				snake_case	:     Union[str, Any]=32   ,				snake_case	:     Any=768   ,				snake_case	:     Optional[Any]=12   ,				snake_case	:     Tuple=12   ,				snake_case	:     List[str]=3_072   ,				snake_case	:     int="gelu"   ,				snake_case	:     int=0.1   ,				snake_case	:     Tuple=0.1   ,				snake_case	:     List[str]=0.1   ,				snake_case	:     Optional[Any]=True   ,				snake_case	:     List[Any]=0.0   ,				snake_case	:     Tuple=0.1   ,				snake_case	:     int=0.1   ,				snake_case	:     List[str]=0.02   ,				snake_case	:     Dict=1E-5   ,				snake_case	:     Any="group"   ,				snake_case	:     Optional[Any]="gelu"   ,				snake_case	:     List[Any]=(512, 512, 512, 512, 512, 512, 512)   ,				snake_case	:     List[str]=(5, 2, 2, 2, 2, 2, 2)   ,				snake_case	:     Optional[int]=(10, 3, 3, 3, 3, 2, 2)   ,				snake_case	:     List[str]=False   ,				snake_case	:     List[str]=128   ,				snake_case	:     Union[str, Any]=16   ,				snake_case	:     Any=False   ,				snake_case	:     Any=True   ,				snake_case	:     Union[str, Any]=0.05   ,				snake_case	:     str=10   ,				snake_case	:     List[Any]=2   ,				snake_case	:     Tuple=0.0   ,				snake_case	:     Any=10   ,				snake_case	:     Optional[int]=0   ,				snake_case	:     Optional[int]="sum"   ,				snake_case	:     List[Any]=False   ,				snake_case	:     Union[str, Any]=False   ,				snake_case	:     Union[str, Any]=256   ,				snake_case	:     Dict=0   ,				snake_case	:     List[str]=1   ,				snake_case	:     Optional[Any]=2   ,				**snake_case	:     Any   ,				)      ->    Tuple:






									'''simple docstring'''

									super().__init__(**SCREAMING_SNAKE_CASE__   ,				pad_token_id=SCREAMING_SNAKE_CASE__   ,				bos_token_id=SCREAMING_SNAKE_CASE__   ,				eos_token_id=SCREAMING_SNAKE_CASE__					)
									A    =       hidden_size
									A    =       feat_extract_norm
									A    =       feat_extract_activation
									A    =       list(SCREAMING_SNAKE_CASE__					)
									A    =       list(SCREAMING_SNAKE_CASE__					)
									A    =       list(SCREAMING_SNAKE_CASE__					)
									A    =       conv_bias
									A    =       num_conv_pos_embeddings
									A    =       num_conv_pos_embedding_groups
									A    =       len(self.conv_dim					)
									A    =       num_hidden_layers
									A    =       intermediate_size
									A    =       hidden_act
									A    =       num_attention_heads
									A    =       hidden_dropout
									A    =       attention_dropout
									A    =       activation_dropout
									A    =       feat_proj_layer_norm
									A    =       feat_proj_dropout
									A    =       final_dropout
									A    =       layerdrop
									A    =       layer_norm_eps
									A    =       initializer_range
									A    =       vocab_size
									A    =       do_stable_layer_norm
									A    =       use_weighted_layer_sum
									A    =       classifier_proj_size

									if (
									    (len(self.conv_stride					) != self.num_feat_extract_layers)
									    or (len(self.conv_kernel					) != self.num_feat_extract_layers)
									    or (len(self.conv_dim					) != self.num_feat_extract_layers)
									):
																raise ValueError(
																    'Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='
																    ' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='
																    f""" {len(self.conv_dim					)}`, `len(config.conv_stride) = {len(self.conv_stride					)}`,"""
																    f""" `len(config.conv_kernel) = {len(self.conv_kernel					)}`."""					)

									# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
									A    =       apply_spec_augment
									A    =       mask_time_prob
									A    =       mask_time_length
									A    =       mask_time_min_masks
									A    =       mask_feature_prob
									A    =       mask_feature_length
									A    =       mask_feature_min_masks

									# ctc loss
									A    =       ctc_loss_reduction
									A    =       ctc_zero_infinity



		@property
		def        A_		(			self	:     List[Any]					)      ->    Union[str, Any]:






									'''simple docstring'''

									return functools.reduce(operator.mul   ,				self.conv_stride   ,				1					)






"""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__		)




