






'''simple docstring'''


from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize
class  _SCREAMING_SNAKE_CASE				(		SCREAMING_SNAKE_CASE						):


			'''simple docstring'''





			__a				:				str         =       1
			__a				:				List[str]         =       2
			__a				:				Union[str, Any]         =       3






			def __repr__( self				:    str      )				->     Tuple:

									'''simple docstring'''







									return f"{self.__class__.__name__}.{self.name}"







def 						__magic_name__(			_A    ,   _A    ,   _A       ):
						'''simple docstring'''





						UpperCamelCase__     , UpperCamelCase__       =			point
						return degrees(atana(y - miny    ,   x - minx       )       )







def 						__magic_name__(			_A    ,   _A    ,   _A       ):
						'''simple docstring'''





						UpperCamelCase__     , UpperCamelCase__       =			starting
						UpperCamelCase__     , UpperCamelCase__       =			via
						UpperCamelCase__     , UpperCamelCase__       =			target
						UpperCamelCase__       =			degrees(atana(ya - ya    ,   xa - xa       )       )
						via_angle %= 360
						UpperCamelCase__       =			degrees(atana(ya - ya    ,   xa - xa       )       )
						target_angle %= 360
						# t-
						#  \ \
						#   \ v
						#    \|
						#     s
						# via_angle is always lower than target_angle, if direction is left.
						# If they are same, it means they are on a same line of convex hull.
						if target_angle > via_angle:
												return Direction.left
						elif target_angle == via_angle:
												return Direction.straight
						else:
												return Direction.right







def 						__magic_name__(			_A       ):
						'''simple docstring'''





						if len(_A       ) <= 2:
												# There is no convex hull
												raise ValueError("""graham_scan: argument must contain more than 3 points."""       )
						if len(_A       ) == 3:
												return points
						# find the lowest and the most left point
						UpperCamelCase__       =			0
						UpperCamelCase__     , UpperCamelCase__       =			maxsize, maxsize
						for i, point in enumerate(_A       ):
												UpperCamelCase__       =			point[0]
												UpperCamelCase__       =			point[1]
												if y < miny:
																		UpperCamelCase__       =			y
																		UpperCamelCase__       =			x
																		UpperCamelCase__       =			i
												if y == miny and x < minx:
																		UpperCamelCase__       =			x
																		UpperCamelCase__       =			i

    # remove the lowest and the most left point from points for preparing for sort
						points.pop(_A       )

						UpperCamelCase__       =			sorted(_A    ,   key=lambda _A       : angle_comparer(_A    ,   _A    ,   _A       )       )
						# This insert actually costs complexity,
						# and you should instead add (minx, miny) into stack later.
						# I'm using insert just for easy understanding.
						sorted_points.insert(0    ,   (minx, miny)       )

						UpperCamelCase__       =			deque()
						stack.append(sorted_points[0]       )
						stack.append(sorted_points[1]       )
						stack.append(sorted_points[2]       )
						# In any ways, the first 3 points line are towards left.
						# Because we sort them the angle from minx, miny.
						UpperCamelCase__       =			Direction.left

						for i in range(3    ,   len(_A       )       ):
												while True:
																		UpperCamelCase__       =			stack[-2]
																		UpperCamelCase__       =			stack[-1]
																		UpperCamelCase__       =			sorted_points[i]
																		UpperCamelCase__       =			check_direction(_A    ,   _A    ,   _A       )

																		if next_direction == Direction.left:
																								UpperCamelCase__       =			Direction.left
																								break
																		if next_direction == Direction.straight:
																								if current_direction == Direction.left:
																														# We keep current_direction as left.
																														# Because if the straight line keeps as straight,
																														# we want to know if this straight line is towards left.
																														break
																								elif current_direction == Direction.right:
																														# If the straight line is towards right,
																														# every previous points on those straigh line is not convex hull.
																														stack.pop()
																		if next_direction == Direction.right:
																								stack.pop()
												stack.append(sorted_points[i]       )
						return list(_A       )








'''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


lowerCamelCase_					:			List[str]     						=				get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''')
@require_torch
class  _SCREAMING_SNAKE_CASE				(		unittest.TestCase						):


			'''simple docstring'''





			def 					A   ( self				:    Union[str, Any]      )				->     Union[str, Any]:

									'''simple docstring'''







									UpperCamelCase__       =			tempfile.mkdtemp()

									UpperCamelCase__       =			SpeechTaTokenizer(lowercase      )
									tokenizer.save_pretrained(self.tmpdirname      )

									UpperCamelCase__       =			{
									    """feature_size""": 1,
									    """padding_value""": 0.0,
									    """sampling_rate""": 1_6_0_0_0,
									    """do_normalize""": False,
									    """num_mel_bins""": 8_0,
									    """hop_length""": 1_6,
									    """win_length""": 6_4,
									    """win_function""": """hann_window""",
									    """fmin""": 8_0,
									    """fmax""": 7_6_0_0,
									    """mel_floor""": 1e-10,
									    """reduction_factor""": 2,
									    """return_attention_mask""": True,
									}

									UpperCamelCase__       =			os.path.join(self.tmpdirname			,   lowercase      )
									with open(self.feature_extraction_file			,   """w"""			,   encoding="""utf-8"""      ) as fp:
															fp.write(json.dumps(lowercase      ) + """\n"""      )






			def 					A   ( self				:    Union[str, Any]			,   **lowercase				:    List[Any]      )				->     Any:

									'''simple docstring'''







									return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,   **lowercase      )






			def 					A   ( self				:    str			,   **lowercase				:    Tuple      )				->     Optional[Any]:

									'''simple docstring'''







									return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,   **lowercase      )






			def 					A   ( self				:    Union[str, Any]      )				->     str:

									'''simple docstring'''







									shutil.rmtree(self.tmpdirname      )






			def 					A   ( self				:    List[Any]      )				->     Optional[int]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_tokenizer()
									UpperCamelCase__       =			self.get_feature_extractor()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									processor.save_pretrained(self.tmpdirname      )
									UpperCamelCase__       =			SpeechTaProcessor.from_pretrained(self.tmpdirname      )

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

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






			def 					A   ( self				:    Tuple      )				->     Union[str, Any]:

									'''simple docstring'''







									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=self.get_tokenizer()			,   feature_extractor=self.get_feature_extractor()      )
									processor.save_pretrained(self.tmpdirname      )

									UpperCamelCase__       =			self.get_tokenizer(bos_token="""(BOS)"""			,   eos_token="""(EOS)"""      )
									UpperCamelCase__       =			self.get_feature_extractor(do_normalize=lowercase			,   padding_value=1.0      )

									UpperCamelCase__       =			SpeechTaProcessor.from_pretrained(
									    self.tmpdirname			,   bos_token="""(BOS)"""			,   eos_token="""(EOS)"""			,   do_normalize=lowercase			,   padding_value=1.0      )

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

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






			def 					A   ( self				:    List[Any]      )				->     Dict:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			floats_list((3, 1_0_0_0)      )

									UpperCamelCase__       =			feature_extractor(audio=lowercase			,   return_tensors="""np"""      )
									UpperCamelCase__       =			processor(audio=lowercase			,   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				:    List[str]      )				->     Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			floats_list((3, 1_0_0_0)      )

									UpperCamelCase__       =			feature_extractor(audio_target=lowercase			,   return_tensors="""np"""      )
									UpperCamelCase__       =			processor(audio_target=lowercase			,   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[Any]      )				->     Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			"""This is a test string"""

									UpperCamelCase__       =			processor(text=lowercase      )
									UpperCamelCase__       =			tokenizer(lowercase      )

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






			def 					A   ( self				:    List[Any]      )				->     int:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			"""This is a test string"""

									UpperCamelCase__       =			processor(text_target=lowercase      )
									UpperCamelCase__       =			tokenizer(lowercase      )

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






			def 					A   ( self				:    Any      )				->     Tuple:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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

									UpperCamelCase__       =			processor.batch_decode(lowercase      )
									UpperCamelCase__       =			tokenizer.batch_decode(lowercase      )

									self.assertListEqual(lowercase			,   lowercase      )







			def 					A   ( self				:    List[Any]      )				->     List[str]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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