

import shutil
import tempfile
import unittest

import pytest

from transformers import WhisperTokenizer, is_speech_available
from transformers.testing_utils import require_sentencepiece, require_torch, require_torchaudio

from .test_feature_extraction_whisper import floats_list


if is_speech_available():
       from transformers import WhisperFeatureExtractor, WhisperProcessor


UpperCamelCase__	:   Dict								=     50_358
UpperCamelCase__	:   Dict								=     50_362



@require_torch
@require_torchaudio
@require_sentencepiece
class    __snake_case	(     unittest.TestCase							):

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    'openai/whisper-small.en'
      SCREAMING_SNAKE_CASE_						=    tempfile.mkdtemp()

  def     lowerCAmelCase__  (       self    ,		**_A):
      return WhisperTokenizer.from_pretrained(self.checkpoint    ,		**_A)

  def     lowerCAmelCase__  (       self    ,		**_A):
      return WhisperFeatureExtractor.from_pretrained(self.checkpoint    ,		**_A)

  def     lowerCAmelCase__  (       self):
      shutil.rmtree(self.tmpdirname)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)

      processor.save_pretrained(self.tmpdirname)
      SCREAMING_SNAKE_CASE_						=    WhisperProcessor.from_pretrained(self.tmpdirname)

      self.assertEqual(processor.tokenizer.get_vocab()    ,		tokenizer.get_vocab())
      self.assertIsInstance(processor.tokenizer    ,		_A)

      self.assertEqual(processor.feature_extractor.to_json_string()    ,		feature_extractor.to_json_string())
      self.assertIsInstance(processor.feature_extractor    ,		_A)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=self.get_tokenizer()    ,		feature_extractor=self.get_feature_extractor())
      processor.save_pretrained(self.tmpdirname)

      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer(bos_token='(BOS)'    ,		eos_token='(EOS)')
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor(do_normalize=_A    ,		padding_value=1.0)

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor.from_pretrained(
          self.tmpdirname    ,		bos_token='(BOS)'    ,		eos_token='(EOS)'    ,		do_normalize=_A    ,		padding_value=1.0)

      self.assertEqual(processor.tokenizer.get_vocab()    ,		tokenizer_add_kwargs.get_vocab())
      self.assertIsInstance(processor.tokenizer    ,		_A)

      self.assertEqual(processor.feature_extractor.to_json_string()    ,		feature_extractor_add_kwargs.to_json_string())
      self.assertIsInstance(processor.feature_extractor    ,		_A)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)

      SCREAMING_SNAKE_CASE_						=    floats_list((3, 1000))

      SCREAMING_SNAKE_CASE_						=    feature_extractor(_A    ,		return_tensors='np')
      SCREAMING_SNAKE_CASE_						=    processor(_A    ,		return_tensors='np')

      for key in input_feat_extract.keys():
          self.assertAlmostEqual(input_feat_extract[key].sum()    ,		input_processor[key].sum()    ,		delta=1E-2)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)

      SCREAMING_SNAKE_CASE_						=    'This is a test string'

      SCREAMING_SNAKE_CASE_						=    processor(text=_A)

      SCREAMING_SNAKE_CASE_						=    tokenizer(_A)

      for key in encoded_tok.keys():
          self.assertListEqual(encoded_tok[key]    ,		encoded_processor[key])

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)

      SCREAMING_SNAKE_CASE_						=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      SCREAMING_SNAKE_CASE_						=    processor.batch_decode(_A)
      SCREAMING_SNAKE_CASE_						=    tokenizer.batch_decode(_A)

      self.assertListEqual(_A    ,		_A)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)

      self.assertListEqual(
          processor.model_input_names    ,		feature_extractor.model_input_names    ,		msg='`processor` and `feature_extractor` model input names do not match'    ,		)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    self.get_feature_extractor()
      SCREAMING_SNAKE_CASE_						=    self.get_tokenizer()

      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=_A    ,		feature_extractor=_A)
      SCREAMING_SNAKE_CASE_						=    processor.get_decoder_prompt_ids(task='transcribe'    ,		no_timestamps=_A)

      self.assertIsInstance(_A    ,		_A)
      for ids in forced_decoder_ids:
          self.assertIsInstance(_A    ,		(list, tuple))

      SCREAMING_SNAKE_CASE_						=    [TRANSCRIBE, NOTIMESTAMPS]
      self.assertListEqual([ids[-1] for ids in forced_decoder_ids]    ,		_A)

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=self.get_tokenizer()    ,		feature_extractor=self.get_feature_extractor())
      SCREAMING_SNAKE_CASE_						=    processor.get_prompt_ids('Mr. Quilter')
      SCREAMING_SNAKE_CASE_						=    processor.tokenizer.decode(_A)

      self.assertListEqual(prompt_ids.tolist()    ,		[50360, 1770, 13, 2264, 346, 353])
      self.assertEqual(_A    ,		'<|startofprev|> Mr. Quilter')

  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=self.get_tokenizer()    ,		feature_extractor=self.get_feature_extractor())
      SCREAMING_SNAKE_CASE_						=    processor.get_prompt_ids('')
      SCREAMING_SNAKE_CASE_						=    processor.tokenizer.decode(_A)

      self.assertListEqual(prompt_ids.tolist()    ,		[50360, 220])
      self.assertEqual(_A    ,		'<|startofprev|> ')


  def     lowerCAmelCase__  (       self):
      SCREAMING_SNAKE_CASE_						=    WhisperProcessor(tokenizer=self.get_tokenizer()    ,		feature_extractor=self.get_feature_extractor())

      def _test_prompt_error_raised_helper(_A    ,		_A):
          with pytest.raises(_A) as excinfo:
              processor.get_prompt_ids(_A)
          SCREAMING_SNAKE_CASE_						=    f"""Encountered text in the prompt corresponding to disallowed special token: {special_token}."""
          self.assertEqual(_A    ,		str(excinfo.value))

      _test_prompt_error_raised_helper('<|startofprev|> test'    ,		'<|startofprev|>')
      _test_prompt_error_raised_helper('test <|notimestamps|>'    ,		'<|notimestamps|>')
      _test_prompt_error_raised_helper('test <|zh|> test <|transcribe|>'    ,		'<|zh|>')





import random


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		List[Any]							):





    """simple docstring"""


    def is_sorted(_SCREAMING_SNAKE_CASE       :		List[Any]							):
        for i in range(len(_SCREAMING_SNAKE_CASE							) - 1							):
            if collection[i] > collection[i + 1]:
                return False
        return True

    while not is_sorted(_SCREAMING_SNAKE_CASE							):
        random.shuffle(_SCREAMING_SNAKE_CASE							)
    return collection


if __name__ == "__main__":
       UpperCamelCase__	:   Tuple								=     input("Enter numbers separated by a comma:\n").strip()
       UpperCamelCase__	:   List[str]								=     [int(item) for item in user_input.split(",")]
       print(bogo_sort(unsorted))


