'''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								=   logging.get_logger(__name__)

_A								=   {
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
_A								=   [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_7, 3_6_6, 4_3_8, 5_3_2, 6_8_5,
    7_0_5, 7_9_6, 9_3_0, 1_0_5_8, 1_2_2_0, 1_2_6_7, 1_2_7_9, 1_3_0_3, 1_3_4_3, 1_3_7_7,
    1_3_9_1, 1_6_3_5, 1_7_8_2, 1_8_7_5, 2_1_6_2, 2_3_6_1, 2_4_8_8, 3_4_6_7, 4_0_0_8, 4_2_1_1,
    4_6_0_0, 4_8_0_8, 5_2_9_9, 5_8_5_5, 6_3_2_9, 7_2_0_3, 9_6_0_9, 9_9_5_9, 1_0_5_6_3, 1_0_7_8_6,
    1_1_4_2_0, 1_1_7_0_9, 1_1_9_0_7, 1_3_1_6_3, 1_3_6_9_7, 1_3_7_0_0, 1_4_8_0_8, 1_5_3_0_6, 1_6_4_1_0, 1_6_7_9_1,
    1_7_9_9_2, 1_9_2_0_3, 1_9_5_1_0, 2_0_7_2_4, 2_2_3_0_5, 2_2_9_3_5, 2_7_0_0_7, 3_0_1_0_9, 3_0_4_2_0, 3_3_4_0_9,
    3_4_9_4_9, 4_0_2_8_3, 4_0_4_9_3, 4_0_5_4_9, 4_7_2_8_2, 4_9_1_4_6, 5_0_2_5_7, 5_0_3_5_9, 5_0_3_6_0, 5_0_3_6_1
]
_A								=   [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_9, 5_0_3, 5_2_2, 5_4_2, 8_7_3,
    8_9_3, 9_0_2, 9_1_8, 9_2_2, 9_3_1, 1_3_5_0, 1_8_5_3, 1_9_8_2, 2_4_6_0, 2_6_2_7,
    3_2_4_6, 3_2_5_3, 3_2_6_8, 3_5_3_6, 3_8_4_6, 3_9_6_1, 4_1_8_3, 4_6_6_7, 6_5_8_5, 6_6_4_7,
    7_2_7_3, 9_0_6_1, 9_3_8_3, 1_0_4_2_8, 1_0_9_2_9, 1_1_9_3_8, 1_2_0_3_3, 1_2_3_3_1, 1_2_5_6_2, 1_3_7_9_3,
    1_4_1_5_7, 1_4_6_3_5, 1_5_2_6_5, 1_5_6_1_8, 1_6_5_5_3, 1_6_6_0_4, 1_8_3_6_2, 1_8_9_5_6, 2_0_0_7_5, 2_1_6_7_5,
    2_2_5_2_0, 2_6_1_3_0, 2_6_1_6_1, 2_6_4_3_5, 2_8_2_7_9, 2_9_4_6_4, 3_1_6_5_0, 3_2_3_0_2, 3_2_4_7_0, 3_6_8_6_5,
    4_2_8_6_3, 4_7_4_2_5, 4_9_8_7_0, 5_0_2_5_4, 5_0_2_5_8, 5_0_3_6_0, 5_0_3_6_1, 5_0_3_6_2
]


class       UpperCAmelCase__  (       _snake_case			):






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

        # Audio Classification-specific parameters. Feel free to ignore for other classes.
        lowercase_					:       Union[str, Any]     				=					classifier_proj_size
        lowercase_					:       Tuple     				=					use_weighted_layer_sum

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

        lowercase_					:       Tuple     				=					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       UpperCAmelCase__  (       _snake_case			):






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

        if self.use_past:
             self.fill_with_past_key_values_(_a       ,				direction='inputs'				)

        return common_inputs
   def 		_lowerCamelCase (self       ,				_a       ,				_a = -1       ,				_a = -1       ,				_a = False       ,				_a = None       ,				_a = 22_050       ,				_a = 5.0       ,				_a = 220       ,				)    ->     Mapping[str, Any]:
        lowercase_					:       Dict     				=					OrderedDict()
        lowercase_					:       List[str]     				=					OnnxConfig.generate_dummy_inputs(
            self       ,				preprocessor=preprocessor.feature_extractor       ,				batch_size=_a       ,				framework=_a       ,				sampling_rate=_a       ,				time_duration=_a       ,				frequency=_a       ,				)
        lowercase_					:       Optional[int]     				=					encoder_inputs['input_features'].shape[2]
        lowercase_					:       Any     				=					encoder_sequence_length // 2 if self.use_past else seq_length

        lowercase_					:       int     				=					super().generate_dummy_inputs(
            preprocessor.tokenizer       ,				_a       ,				_a       ,				_a       ,				_a				)

        lowercase_					:       str     				=					encoder_inputs.pop('input_features'				)
        lowercase_					:       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 		_lowerCamelCase (self				)    ->     float:
        return 1e-3





'''simple docstring'''




import math
import os
import sys

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[str]     				=					''
     try:
          with open(SCREAMING_SNAKE_CASE_  ,       'rb'							) as binary_file:
               lowercase_					:       Dict     				=					binary_file.read()
          for dat in data:
               lowercase_					:       Union[str, Any]     				=					f'''{dat:08b}'''
               result += curr_byte
          return result
     except OSError:
          print('File not accessible'							)
          sys.exit()

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							):
     lexicon.pop(SCREAMING_SNAKE_CASE_							)
     lowercase_					:       Any     				=					last_match_id

     if math.loga(SCREAMING_SNAKE_CASE_							).is_integer():
          for curr_key in lexicon:
               lowercase_					:       Tuple     				=					'0' + lexicon[curr_key]

     lowercase_					:       Any     				=					bin(SCREAMING_SNAKE_CASE_							)[2:]

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       Dict     				=					{'0': '0', '1': '1'}
     lowercase_				,lowercase_					:       Any     				=					'', ''
     lowercase_					:       List[Any]     				=					len(SCREAMING_SNAKE_CASE_							)

     for i in range(len(SCREAMING_SNAKE_CASE_							)							):
          curr_string += data_bits[i]
          if curr_string not in lexicon:
               continue

          lowercase_					:       str     				=					lexicon[curr_string]
          result += last_match_id
          add_key_to_lexicon(SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)
          index += 1
          lowercase_					:       List[Any]     				=					''

     while curr_string != "" and curr_string not in lexicon:
          curr_string += "0"

     if curr_string != "":
          lowercase_					:       Optional[Any]     				=					lexicon[curr_string]
          result += last_match_id

     return result

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[str]     				=					os.path.getsize(SCREAMING_SNAKE_CASE_							)
     lowercase_					:       Any     				=					bin(SCREAMING_SNAKE_CASE_							)[2:]
     lowercase_					:       Optional[Any]     				=					len(SCREAMING_SNAKE_CASE_							)

     return "0" * (length_length - 1) + file_length_binary + compressed

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[str]     				=					8
     try:
          with open(SCREAMING_SNAKE_CASE_  ,       'wb'							) as opened_file:
               lowercase_					:       List[Any]     				=					[
                   to_write[i : i + byte_length]
                   for i in range(0  ,       len(SCREAMING_SNAKE_CASE_							)  ,       SCREAMING_SNAKE_CASE_							)
               ]

               if len(result_byte_array[-1]							) % byte_length == 0:
                    result_byte_array.append('10000000'							)
               else:
                    result_byte_array[-1] += "1" + "0" * (
                        byte_length - len(result_byte_array[-1]							) - 1
                    )

               for elem in result_byte_array:
                    opened_file.write(int(SCREAMING_SNAKE_CASE_  ,       2							).to_bytes(1  ,       byteorder='big'							)							)
     except OSError:
          print('File not accessible'							)
          sys.exit()

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[str]     				=					read_file_binary(SCREAMING_SNAKE_CASE_							)
     lowercase_					:       List[str]     				=					compress_data(SCREAMING_SNAKE_CASE_							)
     lowercase_					:       Union[str, Any]     				=					add_file_length(SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)
     write_file_binary(SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)


if __name__ == "__main__":
 compress(sys.argv[1], sys.argv[2])




