import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : Optional[Any]      =			''
   __UpperCAmelCase : str      =			(
       None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
   )
   __UpperCAmelCase : str      =			None  # compression type in fsspec. ex: "gzip"
   __UpperCAmelCase : str      =			None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz


   def __init__(self     :						List[str]       ,  __UpperCAmelCase     :						str = ""       ,  __UpperCAmelCase     :						Optional[str] = None       ,  __UpperCAmelCase     :						Optional[dict] = None       ,  **__UpperCAmelCase     :						Union[str, Any]		)						->				Dict:
         """simple docstring"""



         super().__init__(self       ,  **__UpperCAmelCase		)
         # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
         UpperCAmelCase__								=  fsspec.open(
             __UpperCAmelCase       ,  mode="rb"       ,  protocol=__UpperCAmelCase       ,  compression=self.compression       ,  client_kwargs={
                 "requote_redirect_url": False,  # see https://github.com/huggingface/datasets/pull/5459
                 "trust_env": True,  # Enable reading proxy env variables.
                 **(target_options or {}).pop("client_kwargs"       ,  {}		),  # To avoid issues if it was already passed.
             }       ,  **(target_options or {})       ,  )
         UpperCAmelCase__								=  os.path.basename(self.file.path.split("::"		)[0]		)
         UpperCAmelCase__								=  (
             self.compressed_name[: self.compressed_name.rindex("."		)]
             if "." in self.compressed_name
             else self.compressed_name
         )
         UpperCAmelCase__								=  None


   @classmethod
   def 			lowercase_      (cls     :						int       ,  __UpperCAmelCase     :						Union[str, Any]		)						->				Dict:
         """simple docstring"""



         return super()._strip_protocol(__UpperCAmelCase		).lstrip("/"		)


   def 			lowercase_      (self     :						Any		)						->				Any:
         """simple docstring"""



         if self.dir_cache is None:
               UpperCAmelCase__								=  {**self.file.fs.info(self.file.path		), "name": self.uncompressed_name}
               UpperCAmelCase__								=  {f["name"]: f}


   def 			lowercase_      (self     :						Union[str, Any]       ,  __UpperCAmelCase     :						str		)						->				Union[str, Any]:
         """simple docstring"""



         return self.file.open().read()





   def 			lowercase_      (self     :						Any       ,  __UpperCAmelCase     :						str       ,  __UpperCAmelCase     :						str = "rb"       ,  __UpperCAmelCase     :						Any=None       ,  __UpperCAmelCase     :						str=True       ,  __UpperCAmelCase     :						Optional[Any]=None       ,  **__UpperCAmelCase     :						str       ,  )						->				Dict:
         """simple docstring"""



         UpperCAmelCase__								=  self._strip_protocol(__UpperCAmelCase		)
         if mode != "rb":
               raise ValueError(f"""Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"""		)
         return self.file.open()





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : Optional[int]      =			'bz2'
   __UpperCAmelCase : Dict      =			'bz2'
   __UpperCAmelCase : Dict      =			'.bz2'





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : Optional[int]      =			'gzip'
   __UpperCAmelCase : Optional[Any]      =			'gzip'
   __UpperCAmelCase : Union[str, Any]      =			'.gz'





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : List[str]      =			'lz4'
   __UpperCAmelCase : str      =			'lz4'
   __UpperCAmelCase : Any      =			'.lz4'





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : str      =			'xz'
   __UpperCAmelCase : int      =			'xz'
   __UpperCAmelCase : Union[str, Any]      =			'.xz'





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : str      =			'zstd'
   __UpperCAmelCase : str      =			'zstd'
   __UpperCAmelCase : Optional[Any]      =			'.zst'


   def __init__(self     :						List[Any]       ,  __UpperCAmelCase     :						str       ,  __UpperCAmelCase     :						str = "rb"       ,  __UpperCAmelCase     :						Optional[str] = None       ,  __UpperCAmelCase     :						Optional[dict] = None       ,  __UpperCAmelCase     :						int = DEFAULT_BLOCK_SIZE       ,  **__UpperCAmelCase     :						List[str]       ,  )						->				List[str]:
         """simple docstring"""



         super().__init__(
             fo=__UpperCAmelCase       ,  mode=__UpperCAmelCase       ,  target_protocol=__UpperCAmelCase       ,  target_options=__UpperCAmelCase       ,  block_size=__UpperCAmelCase       ,  **__UpperCAmelCase       ,  )
         # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
         #
         # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
         #     out.close = close
         # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
         #
         # see https://github.com/intake/filesystem_spec/issues/725
         UpperCAmelCase__								=  self.file.__enter__





         class      A							:


            def __init__(self     :						List[Any]       ,  __UpperCAmelCase     :						Any		)						->				List[str]:
                  """simple docstring"""



                  UpperCAmelCase__								=  file_


            def __enter__(self     :						List[str]		)						->				Tuple:
                  """simple docstring"""



                  self._file.__enter__()
                  return self


            def __exit__(self     :						int       ,  *__UpperCAmelCase     :						Any       ,  **__UpperCAmelCase     :						Tuple		)						->				str:
                  """simple docstring"""



                  self._file.__exit__(*__UpperCAmelCase       ,  **__UpperCAmelCase		)


            def __iter__(self     :						str		)						->				List[Any]:
                  """simple docstring"""



                  return iter(self._file		)


            def 			lowercase_      (self     :						int		)						->				Any:
                  """simple docstring"""



                  return next(self._file		)





            def __getattr__(self     :						Optional[int]       ,  __UpperCAmelCase     :						Any		)						->				Dict:
                  """simple docstring"""



                  return getattr(self._file       ,  __UpperCAmelCase		)

         def fixed_enter(*__UpperCAmelCase     :						Tuple       ,  **__UpperCAmelCase     :						Union[str, Any]		):
               return WrappedFile(_enter(*__UpperCAmelCase       ,  **__UpperCAmelCase		)		)

         UpperCAmelCase__								=  fixed_enter









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

_UpperCAmelCase		:  Tuple	=   logging.get_logger(__name__)

_UpperCAmelCase		:  Dict	=   {
    "openai/whisper-base": "https://huggingface.co/openai/whisper-base/resolve/main/config.json",
}

# fmt: off
_UpperCAmelCase		:  Union[str, 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, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
_UpperCAmelCase		:  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, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]




class       __lowerCAmelCase				(							lowerCAmelCase):
       _a           =  '''whisper'''
       _a           =  ['''past_key_values''']
       _a           =  {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}






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

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

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

         lowercase			:Any							=  median_filter_width

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







class       __lowerCAmelCase				(							lowerCAmelCase):






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    str ):
         lowercase			:Tuple							=  OrderedDict(
             [
                 ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
             ] )
         if self.use_past:
           lowercase			:List[Any]							=  {0: "batch"}
         else:
           lowercase			:str							=  {0: "batch", 1: "decoder_sequence"}

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

         return common_inputs






       def     SCREAMING_SNAKE_CASE			(      self:    Dict				,    _lowerCAmelCase:    Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]				,    _lowerCAmelCase:    int = -1				,    _lowerCAmelCase:    int = -1				,    _lowerCAmelCase:    bool = False				,    _lowerCAmelCase:    Optional["TensorType"] = None				,    _lowerCAmelCase:    int = 2_20_50				,    _lowerCAmelCase:    float = 5.0				,    _lowerCAmelCase:    int = 2_20				,    ):
         lowercase			:List[str]							=  OrderedDict()
         lowercase			:str							=  OnnxConfig.generate_dummy_inputs(
             self				,    preprocessor=preprocessor.feature_extractor				,    batch_size=_lowerCAmelCase				,    framework=_lowerCAmelCase				,    sampling_rate=_lowerCAmelCase				,    time_duration=_lowerCAmelCase				,    frequency=_lowerCAmelCase				,    )
         lowercase			:Optional[Any]							=  encoder_inputs["input_features"].shape[2]
         lowercase			:List[str]							=  encoder_sequence_length // 2 if self.use_past else seq_length

         lowercase			:Dict							=  super().generate_dummy_inputs(
             preprocessor.tokenizer				,    _lowerCAmelCase				,    _lowerCAmelCase				,    _lowerCAmelCase				,    _lowerCAmelCase )

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

         if "past_key_values" in decoder_inputs:
           lowercase			:List[str]							=  decoder_inputs.pop("past_key_values" )

         return dummy_inputs






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    str ):
         return 1e-3



