



"""simple docstring"""
from __future__ import annotations

from collections.abc import Iterable
class    a		:



  def __init__(  self	:   List[Any]    ,						lowerCAmelCase	:   int    ,						lowerCAmelCase	:   Tuple						)       ->   Optional[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =float(lowerCAmelCase						), float(lowerCAmelCase						)



  def __eq__(  self	:   str    ,						lowerCAmelCase	:   List[Any]						)       ->   Optional[Any]:


     '''simple docstring'''




     return self.x == other.x and self.y == other.y



  def __ne__(  self	:   Any    ,						lowerCAmelCase	:   Optional[Any]						)       ->   int:


     '''simple docstring'''




     return not self == other



  def __gt__(  self	:   str    ,						lowerCAmelCase	:   List[str]						)       ->   Union[str, Any]:


     '''simple docstring'''




     if self.x > other.x:
        return True
     elif self.x == other.x:
        return self.y > other.y
     return False



  def __lt__(  self	:   Optional[int]    ,						lowerCAmelCase	:   Tuple						)       ->   Any:


     '''simple docstring'''




     return not self > other



  def __ge__(  self	:   List[str]    ,						lowerCAmelCase	:   Any						)       ->   Union[str, Any]:


     '''simple docstring'''




     if self.x > other.x:
        return True
     elif self.x == other.x:
        return self.y >= other.y
     return False



  def __le__(  self	:   Tuple    ,						lowerCAmelCase	:   Dict						)       ->   Dict:


     '''simple docstring'''




     if self.x < other.x:
        return True
     elif self.x == other.x:
        return self.y <= other.y
     return False



  def __repr__(  self	:   Tuple						)       ->   str:


     '''simple docstring'''




     return f'''({self.x}, {self.y})'''





  def __hash__(  self	:   List[str]						)       ->   int:


     '''simple docstring'''




     return hash(self.x						)







def        __magic_name__			(							lowercase							,     ):
   SCREAMING_SNAKE_CASE_:	list[Point]            =[]
   if list_of_tuples:
      for p in list_of_tuples:
         if isinstance(lowercase							,     lowercase	):
            points.append(lowercase	)
         else:
            try:
               points.append(Point(p[0]							,     p[1]	)	)
            except (IndexError, TypeError):
               print(
                   f'''Ignoring deformed point {p}. All points'''
                   """ must have at least 2 coordinates."""	)
   return points





def        __magic_name__			(							lowercase	):

   if not hasattr(lowercase							,     """__iter__"""	):
      SCREAMING_SNAKE_CASE_:	str            =f'''Expecting an iterable object but got an non-iterable type {points}'''
      raise ValueError(lowercase	)

   if not points:
      SCREAMING_SNAKE_CASE_:	Tuple            =f'''Expecting a list of points but got {points}'''
      raise ValueError(lowercase	)

   return _construct_points(lowercase	)





def        __magic_name__			(							lowercase							,     lowercase							,     lowercase	):
   SCREAMING_SNAKE_CASE_:	List[Any]            =(a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
   return det





def        __magic_name__			(							lowercase	):
   SCREAMING_SNAKE_CASE_:	Optional[Any]            =sorted(_validate_input(lowercase	)	)
   SCREAMING_SNAKE_CASE_:	str            =len(lowercase	)
   SCREAMING_SNAKE_CASE_:	int            =set()

   for i in range(n - 1	):
      for j in range(i + 1							,     lowercase	):
         SCREAMING_SNAKE_CASE_:	Optional[int]            =False
         SCREAMING_SNAKE_CASE_:	Any            =True
         for k in range(lowercase	):
            if k != i and k != j:
               SCREAMING_SNAKE_CASE_:	Tuple            =_det(points[i]							,     points[j]							,     points[k]	)

               if det_k > 0:
                  SCREAMING_SNAKE_CASE_:	List[Any]            =True
               elif det_k < 0:
                  SCREAMING_SNAKE_CASE_:	int            =True
               else:
                  # point[i], point[j], point[k] all lie on a straight line
                  # if point[k] is to the left of point[i] or it's to the
                  # right of point[j], then point[i], point[j] cannot be
                  # part of the convex hull of A
                  if points[k] < points[i] or points[k] > points[j]:
                     SCREAMING_SNAKE_CASE_:	Any            =False
                     break

            if points_left_of_ij and points_right_of_ij:
               SCREAMING_SNAKE_CASE_:	List[str]            =False
               break

         if ij_part_of_convex_hull:
            convex_set.update([points[i], points[j]]	)

   return sorted(lowercase	)





def        __magic_name__			(							lowercase	):
   SCREAMING_SNAKE_CASE_:	List[str]            =sorted(_validate_input(lowercase	)	)
   SCREAMING_SNAKE_CASE_:	Dict            =len(lowercase	)

   # divide all the points into an upper hull and a lower hull
   # the left most point and the right most point are definitely
   # members of the convex hull by definition.
   # use these two anchors to divide all the points into two hulls,
   # an upper hull and a lower hull.

   # all points to the left (above) the line joining the extreme points belong to the
   # upper hull
   # all points to the right (below) the line joining the extreme points below to the
   # lower hull
   # ignore all points on the line joining the extreme points since they cannot be
   # part of the convex hull

   SCREAMING_SNAKE_CASE_:	List[str]            =points[0]
   SCREAMING_SNAKE_CASE_:	int            =points[n - 1]

   SCREAMING_SNAKE_CASE_:	Union[str, Any]            ={left_most_point, right_most_point}
   SCREAMING_SNAKE_CASE_:	Optional[Any]            =[]
   SCREAMING_SNAKE_CASE_:	List[Any]            =[]

   for i in range(1							,     n - 1	):
      SCREAMING_SNAKE_CASE_:	List[Any]            =_det(lowercase							,     lowercase							,     points[i]	)

      if det > 0:
         upper_hull.append(points[i]	)
      elif det < 0:
         lower_hull.append(points[i]	)

   _construct_hull(lowercase							,     lowercase							,     lowercase							,     lowercase	)
   _construct_hull(lowercase							,     lowercase							,     lowercase							,     lowercase	)

   return sorted(lowercase	)





def        __magic_name__			(							lowercase							,     lowercase							,     lowercase							,     lowercase	):
   if points:
      SCREAMING_SNAKE_CASE_:	List[str]            =None
      SCREAMING_SNAKE_CASE_:	List[Any]            =float("""-inf"""	)
      SCREAMING_SNAKE_CASE_:	Dict            =[]

      for p in points:
         SCREAMING_SNAKE_CASE_:	Dict            =_det(lowercase							,     lowercase							,     lowercase	)

         if det > 0:
            candidate_points.append(lowercase	)

            if det > extreme_point_distance:
               SCREAMING_SNAKE_CASE_:	List[str]            =det
               SCREAMING_SNAKE_CASE_:	List[Any]            =p

      if extreme_point:
         _construct_hull(lowercase							,     lowercase							,     lowercase							,     lowercase	)
         convex_set.add(lowercase	)
         _construct_hull(lowercase							,     lowercase							,     lowercase							,     lowercase	)





def        __magic_name__			(							lowercase	):
   SCREAMING_SNAKE_CASE_:	Optional[int]            =sorted(_validate_input(lowercase	)	)
   SCREAMING_SNAKE_CASE_:	str            =len(lowercase	)

   SCREAMING_SNAKE_CASE_:	List[str]            =points[:2]
   for i in range(2							,     lowercase	):
      SCREAMING_SNAKE_CASE_:	List[str]            =_det(convex_hull[1]							,     convex_hull[0]							,     points[i]	)
      if det > 0:
         convex_hull.insert(0							,     points[i]	)
         break
      elif det < 0:
         convex_hull.append(points[i]	)
         break
      else:
         SCREAMING_SNAKE_CASE_:	int            =points[i]
   i += 1

   for j in range(lowercase							,     lowercase	):
      if (
          _det(convex_hull[0]							,     convex_hull[-1]							,     points[j]	) > 0
          and _det(convex_hull[-1]							,     convex_hull[0]							,     points[1]	) < 0
      ):
         # The point lies within the convex hull
         continue

      convex_hull.insert(0							,     points[j]	)
      convex_hull.append(points[j]	)
      while _det(convex_hull[0]							,     convex_hull[1]							,     convex_hull[2]	) >= 0:
         del convex_hull[1]
      while _det(convex_hull[-1]							,     convex_hull[-2]							,     convex_hull[-3]	) <= 0:
         del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
   return sorted(convex_hull[1:] if len(lowercase	) > 3 else convex_hull	)





def        __magic_name__			(							):
   SCREAMING_SNAKE_CASE_:	str            =[
       (0, 3),
       (2, 2),
       (1, 1),
       (2, 1),
       (3, 0),
       (0, 0),
       (3, 3),
       (2, -1),
       (2, -4),
       (1, -3),
   ]
   # the convex set of points is
   # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
   SCREAMING_SNAKE_CASE_:	Tuple            =convex_hull_bf(lowercase	)

   SCREAMING_SNAKE_CASE_:	Any            =convex_hull_recursive(lowercase	)
   assert results_bf == results_recursive

   SCREAMING_SNAKE_CASE_:	Optional[int]            =convex_hull_melkman(lowercase	)
   assert results_bf == results_melkman

   print(lowercase	)


if __name__ == "__main__":
   main()









"""simple docstring"""
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       =     5_0_3_5_8
_UpperCAmelCase       =     5_0_3_6_2
@require_torch
@require_torchaudio
@require_sentencepiece
class    a		(					unittest.TestCase    ):



  def 		lowerCamelCase__    (  self	:   Dict						)       ->   Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	List[Any]            ="""openai/whisper-small.en"""
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =tempfile.mkdtemp()



  def 		lowerCamelCase__    (  self	:   Any    ,						**lowerCAmelCase	:   str						)       ->   str:


     '''simple docstring'''




     return WhisperTokenizer.from_pretrained(self.checkpoint    ,						**lowerCAmelCase						)



  def 		lowerCamelCase__    (  self	:   str    ,						**lowerCAmelCase	:   Optional[Any]						)       ->   Optional[Any]:


     '''simple docstring'''




     return WhisperFeatureExtractor.from_pretrained(self.checkpoint    ,						**lowerCAmelCase						)



  def 		lowerCamelCase__    (  self	:   Tuple						)       ->   Optional[Any]:


     '''simple docstring'''




     shutil.rmtree(self.tmpdirname						)



  def 		lowerCamelCase__    (  self	:   int						)       ->   str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_tokenizer()
     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_feature_extractor()

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

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

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

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



  def 		lowerCamelCase__    (  self	:   str						)       ->   Optional[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     processor.save_pretrained(self.tmpdirname						)

     SCREAMING_SNAKE_CASE_:	int            =self.get_tokenizer(bos_token="""(BOS)"""    ,						eos_token="""(EOS)"""						)
     SCREAMING_SNAKE_CASE_:	Dict            =self.get_feature_extractor(do_normalize=lowerCAmelCase    ,						padding_value=1.0						)

     SCREAMING_SNAKE_CASE_:	Optional[int]            =WhisperProcessor.from_pretrained(
         self.tmpdirname    ,						bos_token="""(BOS)"""    ,						eos_token="""(EOS)"""    ,						do_normalize=lowerCAmelCase    ,						padding_value=1.0						)

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

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



  def 		lowerCamelCase__    (  self	:   Tuple						)       ->   Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Tuple            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Dict            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	Dict            =floats_list((3, 1000)						)

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =feature_extractor(lowerCAmelCase    ,						return_tensors="""np"""						)
     SCREAMING_SNAKE_CASE_:	str            =processor(lowerCAmelCase    ,						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	:   Tuple						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	List[str]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	str            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	List[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	List[str]            ="""This is a test string"""

     SCREAMING_SNAKE_CASE_:	Tuple            =processor(text=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	List[Any]            =tokenizer(lowerCAmelCase						)

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



  def 		lowerCamelCase__    (  self	:   Optional[Any]						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	str            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

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

     SCREAMING_SNAKE_CASE_:	Optional[int]            =processor.batch_decode(lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:	Dict            =tokenizer.batch_decode(lowerCAmelCase						)

     self.assertListEqual(lowerCAmelCase    ,						lowerCAmelCase						)



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


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	str            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	List[Any]            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     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	:   Optional[int]						)       ->   Union[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	Any            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	List[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:	Any            =processor.get_decoder_prompt_ids(task="""transcribe"""    ,						no_timestamps=lowerCAmelCase						)

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

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



  def 		lowerCamelCase__    (  self	:   List[str]						)       ->   List[str]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     SCREAMING_SNAKE_CASE_:	Optional[int]            =processor.get_prompt_ids("""Mr. Quilter"""						)
     SCREAMING_SNAKE_CASE_:	List[str]            =processor.tokenizer.decode(lowerCAmelCase						)

     self.assertListEqual(prompt_ids.tolist()    ,						[5_0360, 1770, 13, 2264, 346, 353]						)
     self.assertEqual(lowerCAmelCase    ,						"""<|startofprev|> Mr. Quilter"""						)



  def 		lowerCamelCase__    (  self	:   Dict						)       ->   Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     SCREAMING_SNAKE_CASE_:	int            =processor.get_prompt_ids(""""""						)
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =processor.tokenizer.decode(lowerCAmelCase						)

     self.assertListEqual(prompt_ids.tolist()    ,						[5_0360, 220]						)
     self.assertEqual(lowerCAmelCase    ,						"""<|startofprev|> """						)





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


     '''simple docstring'''




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

     def _test_prompt_error_raised_helper(lowerCAmelCase	:   List[str]    ,						lowerCAmelCase	:   int						):
        with pytest.raises(lowerCAmelCase						) as excinfo:
           processor.get_prompt_ids(lowerCAmelCase						)
        SCREAMING_SNAKE_CASE_:	List[Any]            =f'''Encountered text in the prompt corresponding to disallowed special token: {special_token}.'''
        self.assertEqual(lowerCAmelCase    ,						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|>"""						)



