'''simple docstring'''






import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
   from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse('''1.6'''):
   _UpperCAmelCase    :     List[str]         =       True
   from torch.cuda.amp import autocast


_UpperCAmelCase    :     Union[str, Any]         =       logging.getLogger(__name__)







@dataclass
class lowercase_       :







   """simple docstring"""

   __lowerCAmelCase         =   field(
       metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}			)
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}    ,    )
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "Whether to freeze the feature extractor layers of the model."}			)
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "Whether to log verbose messages or not."}    ,    )
   __lowerCAmelCase         =   field(
       default=2.0    ,    metadata={"help": "Maximum temperature for gumbel softmax."}			)
   __lowerCAmelCase         =   field(
       default=0.5    ,    metadata={"help": "Minimum temperature for gumbel softmax."}			)
   __lowerCAmelCase         =   field(
       default=0.9_9_9_9_9_5    ,    metadata={"help": "Decay of gumbel temperature during training."}			)






def  _SCREAMING_SNAKE_CASE		(      __snake_case							:			ModelArguments   ,		__snake_case							:			TrainingArguments				):
     logging.basicConfig(
         format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'   ,		datefmt='%m/%d/%Y %H:%M:%S'   ,		handlers=[logging.StreamHandler(sys.stdout				)]   ,		)
     _A    		=  logging.WARNING
     if model_args.verbose_logging:
          _A    		=  logging.DEBUG
     elif trainer_utils.is_main_process(training_args.local_rank				):
          _A    		=  logging.INFO
     logger.setLevel(__snake_case				)







@dataclass
class lowercase_       :







   """simple docstring"""

   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "The name of the dataset to use (via the datasets library)."}			)
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}			)
   __lowerCAmelCase         =   field(
       default="train"    ,    metadata={
           "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
       }    ,    )
   __lowerCAmelCase         =   field(
       default="validation"    ,    metadata={
           "help": (
               "The name of the validation data set split to use (via the datasets library). Defaults to 'validation'"
           )
       }    ,    )
   __lowerCAmelCase         =   field(
       default="file"    ,    metadata={"help": "Column in the dataset that contains speech file path. Defaults to 'file'"}    ,    )
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "Overwrite the cached preprocessed datasets or not."}			)
   __lowerCAmelCase         =   field(
       default=1    ,    metadata={
           "help": "The percentage of the train set used as validation set in case there's no validation split"
       }    ,    )
   __lowerCAmelCase         =   field(
       default=_UpperCamelCase    ,    metadata={"help": "The number of processes to use for the preprocessing."}    ,    )
   __lowerCAmelCase         =   field(
       default=2_0.0    ,    metadata={"help": "Filter audio files that are longer than `max_duration_in_seconds` seconds"}			)







@dataclass
class lowercase_       :







   """simple docstring"""

   __lowerCAmelCase         =   42
   __lowerCAmelCase         =   42
   __lowerCAmelCase         =   "longest"
   __lowerCAmelCase         =   None
   __lowerCAmelCase         =   None
   def __call__(      self      :			int, UpperCamelCase__      :			List[Dict[str, Union[List[int], torch.Tensor]]]     )  ->			Dict[str, torch.Tensor]:
        # reformat list to dict and set to pytorch format
        _A    		=  self.feature_extractor.pad(
            UpperCamelCase__, max_length=self.max_length, padding=self.padding, pad_to_multiple_of=self.pad_to_multiple_of, return_tensors='pt', )
        _A    		=  self.model._get_feat_extract_output_lengths(batch['input_values'].shape[-1]     )

        _A    		=  batch['input_values'].shape[0]

        # make sure that no loss is computed on padded inputs
        if batch["attention_mask"] is not None:
             # compute real output lengths according to convolution formula
             _A    		=  self.model._get_feat_extract_output_lengths(batch['attention_mask'].sum(-1     )     ).to(
                 torch.long     )

             _A    		=  torch.zeros(
                 (batch_size, mask_indices_seq_length), dtype=torch.long, device=batch['input_values'].device     )

             # these two operations makes sure that all values
             # before the output lengths indices are attended to
             _A    		=  1
             _A    		=  attention_mask.flip([-1]     ).cumsum(-1     ).flip([-1]     ).bool()

        # sample randomly masked indices
        _A    		=  _compute_mask_indices(
            (batch_size, mask_indices_seq_length), self.model.config.mask_time_prob, self.model.config.mask_time_length, attention_mask=UpperCamelCase__, min_masks=2, )

        return batch







class lowercase_       (		_UpperCamelCase			):







   """simple docstring"""

   def __init__(      self      :			Union[str, Any], *UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			Union[str, Any]=1, UpperCamelCase__      :			List[str]=0, UpperCamelCase__      :			int=1.0, **UpperCamelCase__      :			Dict     )  ->			str:
        super().__init__(*UpperCamelCase__, **UpperCamelCase__     )
        _A    		=  0
        _A    		=  max_gumbel_temp
        _A    		=  min_gumbel_temp
        _A    		=  gumbel_temp_decay

   def 	__UpperCAmelCase   (      self      :			Optional[Any], UpperCamelCase__      :			nn.Module, UpperCamelCase__      :			Dict[str, Union[torch.Tensor, Any]]     )  ->			torch.Tensor:
        model.train()
        _A    		=  self._prepare_inputs(UpperCamelCase__     )

        if self.use_amp:
             with autocast():
                  _A    		=  self.compute_loss(UpperCamelCase__, UpperCamelCase__     )
        else:
             _A    		=  self.compute_loss(UpperCamelCase__, UpperCamelCase__     )

        if self.args.n_gpu > 1 or self.deepspeed:
             if model.module.config.ctc_loss_reduction == "mean":
                  _A    		=  loss.mean()
             elif model.module.config.ctc_loss_reduction == "sum":
                  _A    		=  loss.sum() / (inputs['mask_time_indices']).sum()
             else:
                  raise ValueError(f'{model.config.ctc_loss_reduction} is not valid. Choose one of [\'mean\', \'sum\']'     )

        if self.args.gradient_accumulation_steps > 1:
             _A    		=  loss / self.args.gradient_accumulation_steps

        if self.use_amp:
             self.scaler.scale(UpperCamelCase__     ).backward()
        elif self.use_apex:
             with amp.scale_loss(UpperCamelCase__, self.optimizer     ) as scaled_loss:
                  scaled_loss.backward()
        elif self.deepspeed:
             self.deepspeed.backward(UpperCamelCase__     )
        else:
             loss.backward()

        self.num_update_step += 1
        # make sure gumbel softmax temperature is decayed
        if self.args.n_gpu > 1 or self.deepspeed:
             model.module.set_gumbel_temperature(
                 max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step, self.min_gumbel_temp     )     )
        else:
             model.set_gumbel_temperature(
                 max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step, self.min_gumbel_temp     )     )

        return loss.detach()






def  _SCREAMING_SNAKE_CASE		(      ):
     # See all possible arguments in src/transformers/training_args.py
     # or by passing the --help flag to this script.
     # We now keep distinct sets of args, for a cleaner separation of concerns.

     _A    		=  HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)

     _A		,       _A		,       _A    		=  parser.parse_args_into_dataclasses()
     configure_logger(__snake_case   ,		__snake_case				)

     # Downloading and loading a dataset from the hub.
     _A    		=  load_dataset(data_args.dataset_name   ,		data_args.dataset_config_name   ,		cache_dir=model_args.cache_dir				)

     if "validation" not in datasets.keys():
          # make sure only "validation" and "train" keys remain"
          _A    		=  DatasetDict()
          _A    		=  load_dataset(
              data_args.dataset_name   ,		data_args.dataset_config_name   ,		split=F'{data_args.train_split_name}[:{data_args.validation_split_percentage}%]'   ,		cache_dir=model_args.cache_dir   ,		)
          _A    		=  load_dataset(
              data_args.dataset_name   ,		data_args.dataset_config_name   ,		split=F'{data_args.train_split_name}[{data_args.validation_split_percentage}%:]'   ,		cache_dir=model_args.cache_dir   ,		)
     else:
          # make sure only "validation" and "train" keys remain"
          _A    		=  DatasetDict()
          _A    		=  load_dataset(
              data_args.dataset_name   ,		data_args.dataset_config_name   ,		split='validation'   ,		cache_dir=model_args.cache_dir   ,		)
          _A    		=  load_dataset(
              data_args.dataset_name   ,		data_args.dataset_config_name   ,		split=F'{data_args.train_split_name}'   ,		cache_dir=model_args.cache_dir   ,		)

     # only normalized-inputs-training is supported
     _A    		=  WavaVecaFeatureExtractor.from_pretrained(
         model_args.model_name_or_path   ,		cache_dir=model_args.cache_dir   ,		do_normalize=__snake_case				)

     def prepare_dataset(__snake_case							:			str				):
          # check that all files have the correct sampling rate
          _A		,       _A    		=  librosa.load(batch[data_args.speech_file_column]   ,		sr=feature_extractor.sampling_rate				)
          return batch

     # load audio files into numpy arrays
     _A    		=  datasets.map(
         __snake_case   ,		num_proc=data_args.preprocessing_num_workers   ,		remove_columns=datasets['train'].column_names				)

     # filter audio files that are too long
     _A    		=  vectorized_datasets.filter(
         lambda __snake_case				: len(data['speech']				) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate				)				)

     def normalize(__snake_case							:			str				):
          return feature_extractor(batch['speech']   ,		sampling_rate=feature_extractor.sampling_rate				)

     # normalize and transform to `BatchFeatures`
     _A    		=  vectorized_datasets.map(
         __snake_case   ,		batched=__snake_case   ,		num_proc=data_args.preprocessing_num_workers   ,		load_from_cache_file=not data_args.overwrite_cache   ,		remove_columns=vectorized_datasets['train'].column_names   ,		)

     # pretraining is only supported for "newer" stable layer norm architecture
     # apply_spec_augment has to be True, mask_feature_prob has to be 0.0
     _A    		=  WavaVecaConfig.from_pretrained(
         model_args.model_name_or_path   ,		cache_dir=model_args.cache_dir   ,		gradient_checkpointing=training_args.gradient_checkpointing   ,		)

     if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
          raise ValueError(
              'PreTraining is only supported for ``config.do_stable_layer_norm=True`` and'
              ' ``config.feat_extract_norm=\'layer\''				)

     _A    		=  WavaVecaForPreTraining(__snake_case				)

     _A    		=  DataCollatorForWavaVecaPretraining(model=__snake_case   ,		feature_extractor=__snake_case				)

     _A    		=  WavaVecaPreTrainer(
         model=__snake_case   ,		data_collator=__snake_case   ,		args=__snake_case   ,		train_dataset=vectorized_datasets['train']   ,		eval_dataset=vectorized_datasets['validation']   ,		tokenizer=__snake_case   ,		max_gumbel_temp=model_args.max_gumbel_temperature   ,		min_gumbel_temp=model_args.min_gumbel_temperature   ,		gumbel_temp_decay=model_args.gumbel_temperature_decay   ,		)
     trainer.train()


if __name__ == "__main__":
   main()







_lowerCAmelCase:						List[str]   				=       'ABCDEFGHIJKLMNOPQRSTUVWXYZ'






def   _lowercase(					):
							a__      =input('Enter message: '     )
							a__      =input('Enter key [alphanumeric]: '     )
							a__      =input('Encrypt/Decrypt [e/d]: '     )

							if mode.lower().startswith('e'     ):
														a__      ='encrypt'
														a__      =encrypt_message(__a    ,     __a     )
							elif mode.lower().startswith('d'     ):
														a__      ='decrypt'
														a__      =decrypt_message(__a    ,     __a     )

							print(f"""\n{mode.title()}ed message:"""     )
							print(__a     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'encrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'decrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str    ,     __a				:						str     ):
							a__      =[]
							a__      =0
							a__      =key.upper()

							for symbol in message:
														a__      =LETTERS.find(symbol.upper()     )
														if num != -1:
																					if mode == "encrypt":
																												num += LETTERS.find(key[key_index]     )
																					elif mode == "decrypt":
																												num -= LETTERS.find(key[key_index]     )

																					num %= len(__a     )

																					if symbol.isupper():
																												translated.append(LETTERS[num]     )
																					elif symbol.islower():
																												translated.append(LETTERS[num].lower()     )

																					key_index += 1
																					if key_index == len(__a     ):
																												a__      =0
														else:
																					translated.append(__a     )
							return "".join(__a     )


if __name__ == "__main__":
	main()

