code: 
  
  
  """simple docstring"""
  
  
  
  
  import json
  import os
  import shutil
  import tempfile
  import unittest
  
  from transformers import is_speech_available, is_torch_available
  from transformers.models.speechta import SpeechTaTokenizer
  from transformers.testing_utils import get_tests_dir, require_torch
  from transformers.utils import FEATURE_EXTRACTOR_NAME
  
  
  if is_speech_available() and is_torch_available():
  					from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor
  
  					from .test_feature_extraction_speechta import floats_list
  
  
  __magic_name__	:   Tuple          =							get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')
  
  
  
  
  @require_torch
  class  __snake_case      (unittest.TestCase     ):
  
  
  
  
  							def      __a      (    self:						Dict      ):
  										__lowerCamelCase        =			tempfile.mkdtemp()
  
  										__lowerCamelCase        =			SpeechTaTokenizer(SCREAMING_SNAKE_CASE_      )
  										tokenizer.save_pretrained(self.tmpdirname      )
  
  										__lowerCamelCase        =			{
  										    'feature_size': 1,
  										    'padding_value': 0.0,
  										    'sampling_rate': 1_60_00,
  										    'do_normalize': False,
  										    'num_mel_bins': 80,
  										    'hop_length': 16,
  										    'win_length': 64,
  										    'win_function': 'hann_window',
  										    'fmin': 80,
  										    'fmax': 76_00,
  										    'mel_floor': 1E-10,
  										    'reduction_factor': 2,
  										    'return_attention_mask': True,
  										}
  
  										__lowerCamelCase        =			os.path.join(self.tmpdirname    ,       SCREAMING_SNAKE_CASE_      )
  										with open(self.feature_extraction_file    ,       """w"""    ,       encoding="""utf-8"""      ) as fp:
  													fp.write(json.dumps(SCREAMING_SNAKE_CASE_      ) + """\n"""      )
  
  
  
  
  							def      __a      (    self:						List[str]    ,       **A_:						Any      ):
  										return SpeechTaTokenizer.from_pretrained(self.tmpdirname    ,       **SCREAMING_SNAKE_CASE_      )
  
  
  
  
  							def      __a      (    self:						Optional[Any]    ,       **A_:						Any      ):
  										return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname    ,       **SCREAMING_SNAKE_CASE_      )
  
  
  
  
  							def      __a      (    self:						int      ):
  										shutil.rmtree(self.tmpdirname      )
  
  
  
  
  							def      __a      (    self:						Optional[int]      ):
  										__lowerCamelCase        =			self.get_tokenizer()
  										__lowerCamelCase        =			self.get_feature_extractor()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										processor.save_pretrained(self.tmpdirname      )
  										__lowerCamelCase        =			SpeechTaProcessor.from_pretrained(self.tmpdirname      )
  
  										self.assertEqual(processor.tokenizer.get_vocab()    ,       tokenizer.get_vocab()      )
  										self.assertIsInstance(processor.tokenizer    ,       SCREAMING_SNAKE_CASE_      )
  
  										self.assertEqual(processor.feature_extractor.to_json_string()    ,       feature_extractor.to_json_string()      )
  										self.assertIsInstance(processor.feature_extractor    ,       SCREAMING_SNAKE_CASE_      )
  
  
  
  
  							def      __a      (    self:						Optional[Any]      ):
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=self.get_tokenizer()    ,       feature_extractor=self.get_feature_extractor()      )
  										processor.save_pretrained(self.tmpdirname      )
  
  										__lowerCamelCase        =			self.get_tokenizer(bos_token="""(BOS)"""    ,       eos_token="""(EOS)"""      )
  										__lowerCamelCase        =			self.get_feature_extractor(do_normalize=SCREAMING_SNAKE_CASE_    ,       padding_value=1.0      )
  
  										__lowerCamelCase        =			SpeechTaProcessor.from_pretrained(
  										    self.tmpdirname    ,       bos_token="""(BOS)"""    ,       eos_token="""(EOS)"""    ,       do_normalize=SCREAMING_SNAKE_CASE_    ,       padding_value=1.0      )
  
  										self.assertEqual(processor.tokenizer.get_vocab()    ,       tokenizer_add_kwargs.get_vocab()      )
  										self.assertIsInstance(processor.tokenizer    ,       SCREAMING_SNAKE_CASE_      )
  
  										self.assertEqual(processor.feature_extractor.to_json_string()    ,       feature_extractor_add_kwargs.to_json_string()      )
  										self.assertIsInstance(processor.feature_extractor    ,       SCREAMING_SNAKE_CASE_      )
  
  
  
  
  							def      __a      (    self:						Tuple      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										__lowerCamelCase        =			floats_list((3, 10_00)      )
  
  										__lowerCamelCase        =			feature_extractor(audio=SCREAMING_SNAKE_CASE_    ,       return_tensors="""np"""      )
  										__lowerCamelCase        =			processor(audio=SCREAMING_SNAKE_CASE_    ,       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      __a      (    self:						Optional[int]      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										__lowerCamelCase        =			floats_list((3, 10_00)      )
  
  										__lowerCamelCase        =			feature_extractor(audio_target=SCREAMING_SNAKE_CASE_    ,       return_tensors="""np"""      )
  										__lowerCamelCase        =			processor(audio_target=SCREAMING_SNAKE_CASE_    ,       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      __a      (    self:						int      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										__lowerCamelCase        =			'This is a test string'
  
  										__lowerCamelCase        =			processor(text=SCREAMING_SNAKE_CASE_      )
  										__lowerCamelCase        =			tokenizer(SCREAMING_SNAKE_CASE_      )
  
  										for key in encoded_tok.keys():
  													self.assertListEqual(encoded_tok[key]    ,       encoded_processor[key]      )
  
  
  
  
  							def      __a      (    self:						List[Any]      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										__lowerCamelCase        =			'This is a test string'
  
  										__lowerCamelCase        =			processor(text_target=SCREAMING_SNAKE_CASE_      )
  										__lowerCamelCase        =			tokenizer(SCREAMING_SNAKE_CASE_      )
  
  										for key in encoded_tok.keys():
  													self.assertListEqual(encoded_tok[key]    ,       encoded_processor[key]      )
  
  
  
  
  							def      __a      (    self:						Optional[int]      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										__lowerCamelCase        =			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  										__lowerCamelCase        =			processor.batch_decode(SCREAMING_SNAKE_CASE_      )
  										__lowerCamelCase        =			tokenizer.batch_decode(SCREAMING_SNAKE_CASE_      )
  
  										self.assertListEqual(SCREAMING_SNAKE_CASE_    ,       SCREAMING_SNAKE_CASE_      )
  
  
  
  
  							def      __a      (    self:						Dict      ):
  										__lowerCamelCase        =			self.get_feature_extractor()
  										__lowerCamelCase        =			self.get_tokenizer()
  
  										__lowerCamelCase        =			SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_    ,       feature_extractor=SCREAMING_SNAKE_CASE_      )
  
  										self.assertListEqual(
  										    processor.model_input_names    ,       feature_extractor.model_input_names    ,       msg="""`processor` and `feature_extractor` model input names do not match"""    ,       )
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  import re
  
  
  
  
  
  def 			a_   (  lowercase__   :list[str]    ):
  
  			def alphanum_key(lowercase__   :int    ):
  						return [int(lowercase__    ) if s.isdigit() else s.lower() for s in re.split("""([0-9]+)""", lowercase__    )]
  
  			return sorted(lowercase__, key=lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  