


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

snake_case__				:	Optional[int]					       =					logging.get_logger(__name__)

snake_case__				:	Optional[Any]					       =					{
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
snake_case__				:	str					       =					[
    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, 1_0563, 1_0786,
    1_1420, 1_1709, 1_1907, 1_3163, 1_3697, 1_3700, 1_4808, 1_5306, 1_6410, 1_6791,
    1_7992, 1_9203, 1_9510, 2_0724, 2_2305, 2_2935, 2_7007, 3_0109, 3_0420, 3_3409,
    3_4949, 4_0283, 4_0493, 4_0549, 4_7282, 4_9146, 5_0257, 5_0359, 5_0360, 5_0361
]
snake_case__				:	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, 1_0428, 1_0929, 1_1938, 1_2033, 1_2331, 1_2562, 1_3793,
    1_4157, 1_4635, 1_5265, 1_5618, 1_6553, 1_6604, 1_8362, 1_8956, 2_0075, 2_1675,
    2_2520, 2_6130, 2_6161, 2_6435, 2_8279, 2_9464, 3_1650, 3_2302, 3_2470, 3_6865,
    4_2863, 4_7425, 4_9870, 5_0254, 5_0258, 5_0360, 5_0361, 5_0362
]





class   SCREAMING_SNAKE_CASE_			(a__						):




       '''simple docstring'''



       _a   							=							"whisper"
       _a   							=							["past_key_values"]
       _a   							=							{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}



       def __init__(						self				:				Any		,				__a				:				List[str]=51_865		,				__a				:				Any=80		,				__a				:				Optional[Any]=6		,				__a				:				str=4		,				__a				:				str=6		,				__a				:				Tuple=4		,				__a				:				Optional[Any]=1_536		,				__a				:				Optional[Any]=1_536		,				__a				:				Union[str, Any]=0.0		,				__a				:				int=0.0		,				__a				:				Union[str, Any]=50_257		,				__a				:				Optional[Any]=True		,				__a				:				List[Any]=True		,				__a				:				Optional[int]="gelu"		,				__a				:				Any=256		,				__a				:				Any=0.0		,				__a				:				Dict=0.0		,				__a				:				str=0.0		,				__a				:				Any=0.02		,				__a				:				Optional[Any]=False		,				__a				:				int=1_500		,				__a				:				Any=448		,				__a				:				int=50_256		,				__a				:				int=50_256		,				__a				:				int=50_256		,				__a				:				Optional[int]=None		,				__a				:				Union[str, Any]=[220, 50_256]		,				__a				:				Tuple=False		,				__a				:				List[str]=256		,				__a				:				Optional[int]=False		,				__a				:				int=0.05		,				__a				:				List[str]=10		,				__a				:				List[Any]=2		,				__a				:				str=0.0		,				__a				:				Dict=10		,				__a				:				List[Any]=0		,				__a				:				int=7		,				**__a				:				Optional[Any]		,				)					->str:
          lowerCamelCase_						:   Union[str, Any]		= vocab_size
          lowerCamelCase_						:   Dict		= num_mel_bins
          lowerCamelCase_						:   Union[str, Any]		= d_model
          lowerCamelCase_						:   Dict		= encoder_layers
          lowerCamelCase_						:   Any		= encoder_attention_heads
          lowerCamelCase_						:   Optional[int]		= decoder_layers
          lowerCamelCase_						:   Tuple		= decoder_attention_heads
          lowerCamelCase_						:   Dict		= decoder_ffn_dim
          lowerCamelCase_						:   Dict		= encoder_ffn_dim
          lowerCamelCase_						:   Tuple		= dropout
          lowerCamelCase_						:   int		= attention_dropout
          lowerCamelCase_						:   Tuple		= activation_dropout
          lowerCamelCase_						:   Union[str, Any]		= activation_function
          lowerCamelCase_						:   List[Any]		= init_std
          lowerCamelCase_						:   Any		= encoder_layerdrop
          lowerCamelCase_						:   str		= decoder_layerdrop
          lowerCamelCase_						:   Dict		= use_cache
          lowerCamelCase_						:   Tuple		= encoder_layers
          lowerCamelCase_						:   Union[str, Any]		= scale_embedding  # scale factor will be sqrt(d_model) if True
          lowerCamelCase_						:   Any		= max_source_positions
          lowerCamelCase_						:   Optional[Any]		= max_target_positions

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

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

          lowerCamelCase_						:   int		= median_filter_width

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







class   SCREAMING_SNAKE_CASE_			(a__						):




       '''simple docstring'''



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

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

          return common_inputs



       def 				_lowerCAmelCase							(						self				:				Dict		,				__a				:				Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]		,				__a				:				int = -1		,				__a				:				int = -1		,				__a				:				bool = False		,				__a				:				Optional["TensorType"] = None		,				__a				:				int = 22_050		,				__a				:				float = 5.0		,				__a				:				int = 220		,				)					->Mapping[str, Any]:
          lowerCamelCase_						:   Any		= OrderedDict()
          lowerCamelCase_						:   str		= OnnxConfig.generate_dummy_inputs(
              self		,				preprocessor=preprocessor.feature_extractor		,				batch_size=__a		,				framework=__a		,				sampling_rate=__a		,				time_duration=__a		,				frequency=__a		,				)
          lowerCamelCase_						:   Union[str, Any]		= encoder_inputs["""input_features"""].shape[2]
          lowerCamelCase_						:   Tuple		= encoder_sequence_length // 2 if self.use_past else seq_length

          lowerCamelCase_						:   Optional[int]		= super().generate_dummy_inputs(
              preprocessor.tokenizer		,				__a		,				__a		,				__a		,				__a							)

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

          if "past_key_values" in decoder_inputs:
             lowerCamelCase_						:   Tuple		= decoder_inputs.pop("""past_key_values"""							)

          return dummy_inputs




       @property
       def 				_lowerCAmelCase							(						self				:				Tuple							)					->float:
          return 1e-3









def    __lowerCamelCase   (      A__						: float						,						A__						: float						,						A__						: float						,						A__						: float						,						A__						: float						,						)     ->    float:
   lowerCamelCase_						:   List[str]		= [redshift, radiation_density, matter_density, dark_energy]
   if any(p < 0 for p in parameters					):
      raise ValueError("""All input parameters must be positive"""					)

   if any(p > 1 for p in parameters[1:4]					):
      raise ValueError("""Relative densities cannot be greater than one"""					)
   else:
      lowerCamelCase_						:   Union[str, Any]		= 1 - (matter_density + radiation_density + dark_energy)

      lowerCamelCase_						:   int		= (
          radiation_density * (redshift + 1) ** 4
          + matter_density * (redshift + 1) ** 3
          + curvature * (redshift + 1) ** 2
          + dark_energy
      )

      lowerCamelCase_						:   Dict		= hubble_constant * e_a ** (1 / 2)
      return hubble


if __name__ == "__main__":
      import doctest

      # run doctest
      doctest.testmod()

      # demo LCDM approximation
      snake_case__				:	str					       =					0.3

      print(
          hubble_parameter(
              hubble_constant=6_8.3,
              radiation_density=1e-4,
              matter_density=matter_density,
              dark_energy=1 - matter_density,
              redshift=0,
          )
      )





