
"""simple docstring"""




from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
    from ...feature_extraction_utils import FeatureExtractionMixin
    from ...tokenization_utils_base import PreTrainedTokenizerBase
    from ...utils import TensorType

A__      :	Dict          =    logging.get_logger(__name__)

A__      :	Optional[int]          =    {
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
A__      :	List[Any]          =    [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1_058, 1_220, 1_267, 1_279, 1_303, 1_343, 1_377,
    1_391, 1_635, 1_782, 1_875, 2_162, 2_361, 2_488, 3_467, 4_008, 4_211,
    4_600, 4_808, 5_299, 5_855, 6_329, 7_203, 9_609, 9_959, 10_563, 10_786,
    11_420, 11_709, 11_907, 13_163, 13_697, 13_700, 14_808, 15_306, 16_410, 16_791,
    17_992, 19_203, 19_510, 20_724, 22_305, 22_935, 27_007, 30_109, 30_420, 33_409,
    34_949, 40_283, 40_493, 40_549, 47_282, 49_146, 50_257, 50_359, 50_360, 50_361
]
A__      :	int          =    [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1_350, 1_853, 1_982, 2_460, 2_627,
    3_246, 3_253, 3_268, 3_536, 3_846, 3_961, 4_183, 4_667, 6_585, 6_647,
    7_273, 9_061, 9_383, 10_428, 10_929, 11_938, 12_033, 12_331, 12_562, 13_793,
    14_157, 14_635, 15_265, 15_618, 16_553, 16_604, 18_362, 18_956, 20_075, 21_675,
    22_520, 26_130, 26_161, 26_435, 28_279, 29_464, 31_650, 32_302, 32_470, 36_865,
    42_863, 47_425, 49_870, 50_254, 50_258, 50_360, 50_361, 50_362
]







class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     _A								=							'whisper'
     _A								=							['past_key_values']
     _A								=							{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}



     def __init__(      self ,			__UpperCamelCase=5_18_65 ,			__UpperCamelCase=80 ,			__UpperCamelCase=6 ,			__UpperCamelCase=4 ,			__UpperCamelCase=6 ,			__UpperCamelCase=4 ,			__UpperCamelCase=15_36 ,			__UpperCamelCase=15_36 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=5_02_57 ,			__UpperCamelCase=True ,			__UpperCamelCase=True ,			__UpperCamelCase="gelu" ,			__UpperCamelCase=2_56 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=0.02 ,			__UpperCamelCase=False ,			__UpperCamelCase=15_00 ,			__UpperCamelCase=4_48 ,			__UpperCamelCase=5_02_56 ,			__UpperCamelCase=5_02_56 ,			__UpperCamelCase=5_02_56 ,			__UpperCamelCase=None ,			__UpperCamelCase=[2_20, 5_02_56] ,			__UpperCamelCase=False ,			__UpperCamelCase=2_56 ,			__UpperCamelCase=False ,			__UpperCamelCase=0.05 ,			__UpperCamelCase=10 ,			__UpperCamelCase=2 ,			__UpperCamelCase=0.0 ,			__UpperCamelCase=10 ,			__UpperCamelCase=0 ,			__UpperCamelCase=7 ,			**__UpperCamelCase ,			)->					int:
          UpperCAmelCase__							: Dict 							=						vocab_size
          UpperCAmelCase__							: Optional[int] 							=						num_mel_bins
          UpperCAmelCase__							: Dict 							=						d_model
          UpperCAmelCase__							: List[Any] 							=						encoder_layers
          UpperCAmelCase__							: List[str] 							=						encoder_attention_heads
          UpperCAmelCase__							: Tuple 							=						decoder_layers
          UpperCAmelCase__							: Union[str, Any] 							=						decoder_attention_heads
          UpperCAmelCase__							: Dict 							=						decoder_ffn_dim
          UpperCAmelCase__							: List[Any] 							=						encoder_ffn_dim
          UpperCAmelCase__							: Union[str, Any] 							=						dropout
          UpperCAmelCase__							: Union[str, Any] 							=						attention_dropout
          UpperCAmelCase__							: Tuple 							=						activation_dropout
          UpperCAmelCase__							: Optional[int] 							=						activation_function
          UpperCAmelCase__							: Tuple 							=						init_std
          UpperCAmelCase__							: List[str] 							=						encoder_layerdrop
          UpperCAmelCase__							: Optional[int] 							=						decoder_layerdrop
          UpperCAmelCase__							: Optional[int] 							=						use_cache
          UpperCAmelCase__							: int 							=						encoder_layers
          UpperCAmelCase__							: List[Any] 							=						scale_embedding  # scale factor will be sqrt(d_model) if True
          UpperCAmelCase__							: Tuple 							=						max_source_positions
          UpperCAmelCase__							: Union[str, Any] 							=						max_target_positions

          # Audio Classification-specific parameters. Feel free to ignore for other classes.
          UpperCAmelCase__							: List[Any] 							=						classifier_proj_size
          UpperCAmelCase__							: List[str] 							=						use_weighted_layer_sum

          # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
          UpperCAmelCase__							: Any 							=						apply_spec_augment
          UpperCAmelCase__							: Tuple 							=						mask_time_prob
          UpperCAmelCase__							: int 							=						mask_time_length
          UpperCAmelCase__							: Tuple 							=						mask_time_min_masks
          UpperCAmelCase__							: Optional[int] 							=						mask_feature_prob
          UpperCAmelCase__							: str 							=						mask_feature_length
          UpperCAmelCase__							: str 							=						mask_feature_min_masks

          UpperCAmelCase__							: Union[str, Any] 							=						median_filter_width

          super().__init__(
              pad_token_id=__UpperCamelCase ,			bos_token_id=__UpperCamelCase ,			eos_token_id=__UpperCamelCase ,			is_encoder_decoder=__UpperCamelCase ,			decoder_start_token_id=__UpperCamelCase ,			suppress_tokens=__UpperCamelCase ,			begin_suppress_tokens=__UpperCamelCase ,			**__UpperCamelCase ,			)







class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     @property
     def  lowerCAmelCase__       (      self  )->					Mapping[str, Mapping[int, str]]:
          UpperCAmelCase__							: List[str] 							=						OrderedDict(
              [
                  ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
              ]  )
          if self.use_past:
               UpperCAmelCase__							: List[str] 							=						{0: "batch"}
          else:
               UpperCAmelCase__							: Optional[Any] 							=						{0: "batch", 1: "decoder_sequence"}

          if self.use_past:
               self.fill_with_past_key_values_(__UpperCamelCase ,			direction="inputs"  )

          return common_inputs



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase = -1 ,			__UpperCamelCase = -1 ,			__UpperCamelCase = False ,			__UpperCamelCase = None ,			__UpperCamelCase = 2_20_50 ,			__UpperCamelCase = 5.0 ,			__UpperCamelCase = 2_20 ,			)->					Mapping[str, Any]:
          UpperCAmelCase__							: Optional[int] 							=						OrderedDict()
          UpperCAmelCase__							: List[str] 							=						OnnxConfig.generate_dummy_inputs(
              self ,			preprocessor=preprocessor.feature_extractor ,			batch_size=__UpperCamelCase ,			framework=__UpperCamelCase ,			sampling_rate=__UpperCamelCase ,			time_duration=__UpperCamelCase ,			frequency=__UpperCamelCase ,			)
          UpperCAmelCase__							: str 							=						encoder_inputs["input_features"].shape[2]
          UpperCAmelCase__							: str 							=						encoder_sequence_length // 2 if self.use_past else seq_length

          UpperCAmelCase__							: Tuple 							=						super().generate_dummy_inputs(
              preprocessor.tokenizer ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )

          UpperCAmelCase__							: int 							=						encoder_inputs.pop("input_features"  )
          UpperCAmelCase__							: Optional[int] 							=						decoder_inputs.pop("decoder_input_ids"  )

          if "past_key_values" in decoder_inputs:
               UpperCAmelCase__							: str 							=						decoder_inputs.pop("past_key_values"  )

          return dummy_inputs



     @property
     def  lowerCAmelCase__       (      self  )->					float:
          return 1E-3





"""simple docstring"""




import unicodedata
from dataclasses import dataclass
from typing import Optional, Union

import numpy as np

from transformers.data.data_collator import DataCollatorMixin
from transformers.file_utils import PaddingStrategy
from transformers.tokenization_utils_base import PreTrainedTokenizerBase



def 							a__ (				lowerCAmelCase	:       str       ,    lowerCAmelCase	:       Optional[Any]       ,    lowerCAmelCase	:       Dict       ,    lowerCAmelCase	:       List[Any]		):






     '''simple docstring'''
     if isinstance(lowerCAmelCase       ,    lowerCAmelCase		):
          UpperCAmelCase__							: Optional[int] 							=						np.full((len(lowerCAmelCase		), sequence_length, 2)       ,    lowerCAmelCase		)
     else:
          UpperCAmelCase__							: Optional[Any] 							=						np.full((len(lowerCAmelCase		), sequence_length)       ,    lowerCAmelCase		)

     for i, tensor in enumerate(lowerCAmelCase		):
          if padding_side == "right":
               if isinstance(lowerCAmelCase       ,    lowerCAmelCase		):
                    UpperCAmelCase__							: Dict 							=						tensor[:sequence_length]
               else:
                    UpperCAmelCase__							: Tuple 							=						tensor[:sequence_length]
          else:
               if isinstance(lowerCAmelCase       ,    lowerCAmelCase		):
                    UpperCAmelCase__							: Optional[Any] 							=						tensor[:sequence_length]
               else:
                    UpperCAmelCase__							: int 							=						tensor[:sequence_length]

     return out_tensor.tolist()



def 							a__ (				lowerCAmelCase	:       Optional[int]		):






     '''simple docstring'''
     UpperCAmelCase__							: Tuple 							=						ord(lowerCAmelCase		)
     if (cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or (cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126):
          return True
     UpperCAmelCase__							: Optional[Any] 							=						unicodedata.category(lowerCAmelCase		)
     if cat.startswith("P"		):
          return True
     return False







@dataclass
class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     _A								=							42
     _A								=							True
     _A								=							None
     _A								=							None
     _A								=							-100
     _A								=							"pt"



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase  )->					List[str]:
          import torch

          UpperCAmelCase__							: Optional[Any] 							=						"label" if "label" in features[0].keys() else "labels"
          UpperCAmelCase__							: Dict 							=						[feature[label_name] for feature in features] if label_name in features[0].keys() else None
          UpperCAmelCase__							: str 							=						self.tokenizer.pad(
              __UpperCamelCase ,			padding=self.padding ,			max_length=self.max_length ,			pad_to_multiple_of=self.pad_to_multiple_of ,			return_tensors="pt" if labels is None else None ,			)

          if labels is None:
               return batch

          UpperCAmelCase__							: Optional[Any] 							=						torch.tensor(batch["entity_ids"]  ).shape[1]
          UpperCAmelCase__							: int 							=						self.tokenizer.padding_side
          if padding_side == "right":
               UpperCAmelCase__							: int 							=						[
                   list(__UpperCamelCase  ) + [self.label_pad_token_id] * (sequence_length - len(__UpperCamelCase  )) for label in labels
               ]
          else:
               UpperCAmelCase__							: List[Any] 							=						[
                   [self.label_pad_token_id] * (sequence_length - len(__UpperCamelCase  )) + list(__UpperCamelCase  ) for label in labels
               ]

          UpperCAmelCase__							: Optional[Any] 							=						[feature["ner_tags"] for feature in features]
          UpperCAmelCase__							: int 							=						padding_tensor(__UpperCamelCase ,			-1 ,			__UpperCamelCase ,			__UpperCamelCase  )
          UpperCAmelCase__							: List[Any] 							=						[feature["original_entity_spans"] for feature in features]
          UpperCAmelCase__							: int 							=						padding_tensor(__UpperCamelCase ,			(-1, -1) ,			__UpperCamelCase ,			__UpperCamelCase  )
          UpperCAmelCase__							: Optional[int] 							=						{k: torch.tensor(__UpperCamelCase ,			dtype=torch.intaa  ) for k, v in batch.items()}

          return batch



