


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin







class      _lowercase					(				__UpperCamelCase):


       """simple docstring"""




       A__   		=     "AutoFeatureExtractor"
       A__   		=     "Speech2Text2Tokenizer"





       def __init__(  self				:     str   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     Union[str, Any]			):


             '''simple docstring'''



             super().__init__(_lowerCAmelCase   , _lowerCAmelCase			)
             lowerCamelCase__						:							Union[str, Any]       =    self.feature_extractor
             lowerCamelCase__						:							Tuple       =    False





       def __call__(  self				:     Any   , *__lowerCamelCase				:     Dict   , **__lowerCamelCase				:     Optional[Any]			):


             '''simple docstring'''



             if self._in_target_context_manager:
                   return self.current_processor(*_lowerCAmelCase   , **_lowerCAmelCase			)

             if "raw_speech" in kwargs:
                   warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."			)
                   lowerCamelCase__						:							Optional[Any]       =    kwargs.pop("raw_speech"			)
             else:
                   lowerCamelCase__						:							Union[str, Any]       =    kwargs.pop("audio"   , _lowerCAmelCase			)
             lowerCamelCase__						:							List[str]       =    kwargs.pop("sampling_rate"   , _lowerCAmelCase			)
             lowerCamelCase__						:							Any       =    kwargs.pop("text"   , _lowerCAmelCase			)
             if len(_lowerCAmelCase			) > 0:
                   lowerCamelCase__						:							Dict       =    args[0]
                   lowerCamelCase__						:							Any       =    args[1:]

             if audio is None and text is None:
                   raise ValueError("You need to specify either an `audio` or `text` input to process."			)

             if audio is not None:
                   lowerCamelCase__						:							Dict       =    self.feature_extractor(_lowerCAmelCase   , *_lowerCAmelCase   , sampling_rate=_lowerCAmelCase   , **_lowerCAmelCase			)
             if text is not None:
                   lowerCamelCase__						:							int       =    self.tokenizer(_lowerCAmelCase   , **_lowerCAmelCase			)

             if text is None:
                   return inputs
             elif audio is None:
                   return encodings
             else:
                   lowerCamelCase__						:							Optional[int]       =    encodings["""input_ids"""]
                   return inputs





       def 		lowerCAmelCase	(  self				:     str   , *__lowerCamelCase				:     Dict   , **__lowerCamelCase				:     str			):


             '''simple docstring'''



             return self.tokenizer.batch_decode(*_lowerCAmelCase   , **_lowerCAmelCase			)





       def 		lowerCAmelCase	(  self				:     Dict   , *__lowerCamelCase				:     Any   , **__lowerCamelCase				:     int			):


             '''simple docstring'''



             return self.tokenizer.decode(*_lowerCAmelCase   , **_lowerCAmelCase			)





       @contextmanager
       def 		lowerCAmelCase	(  self				:     str			):


             '''simple docstring'''



             warnings.warn(
                 "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
                 "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
                 "your audio inputs, or in a separate call."			)
             lowerCamelCase__						:							Dict       =    True
             lowerCamelCase__						:							Tuple       =    self.tokenizer
             yield
             lowerCamelCase__						:							str       =    self.feature_extractor
             lowerCamelCase__						:							List[str]       =    False



from __future__ import annotations

from collections.abc import Iterable







class      SCREAMING_SNAKE_CASE__					:

       def __init__(							self					:     Optional[Any]			,			_lowerCAmelCase					:     Tuple			,			_lowerCAmelCase					:     Tuple			):
           __snake_case			, __snake_case       :				str 			=    float(_lowerCAmelCase			), float(_lowerCAmelCase			)

       def __eq__(							self					:     List[Any]			,			_lowerCAmelCase					:     List[str]			):
           return self.x == other.x and self.y == other.y

       def __ne__(							self					:     Any			,			_lowerCAmelCase					:     Optional[Any]			):
           return not self == other

       def __gt__(							self					:     Union[str, Any]			,			_lowerCAmelCase					:     int			):
           if self.x > other.x:
               return True
           elif self.x == other.x:
               return self.y > other.y
           return False

       def __lt__(							self					:     List[str]			,			_lowerCAmelCase					:     List[str]			):
           return not self > other

       def __ge__(							self					:     List[Any]			,			_lowerCAmelCase					:     List[Any]			):
           if self.x > other.x:
               return True
           elif self.x == other.x:
               return self.y >= other.y
           return False

       def __le__(							self					:     List[Any]			,			_lowerCAmelCase					:     List[Any]			):
           if self.x < other.x:
               return True
           elif self.x == other.x:
               return self.y <= other.y
           return False

       def __repr__(							self					:     str			):
           return f'''({self.x}, {self.y})'''





       def __hash__(							self					:     List[str]			):
           return hash(self.x			)







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point] | list[list[float]] | Iterable[list[float]]		,							):







    '''simple docstring'''
    __snake_case       :				list[Point] 			=    []
    if list_of_tuples:
        for p in list_of_tuples:
            if isinstance(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   ):
                points.append(__SCREAMING_SNAKE_CASE   )
            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 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point] | list[list[float]]   ):







    '''simple docstring'''

    if not hasattr(__SCREAMING_SNAKE_CASE		,							"""__iter__"""   ):
        __snake_case       :				List[str] 			=    F'''Expecting an iterable object but got an non-iterable type {points}'''
        raise ValueError(__SCREAMING_SNAKE_CASE   )

    if not points:
        __snake_case       :				Tuple 			=    F'''Expecting a list of points but got {points}'''
        raise ValueError(__SCREAMING_SNAKE_CASE   )

    return _construct_points(__SCREAMING_SNAKE_CASE   )







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					Point		,							__SCREAMING_SNAKE_CASE       :					Point		,							__SCREAMING_SNAKE_CASE       :					Point   ):







    '''simple docstring'''
    __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 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point]   ):







    '''simple docstring'''
    __snake_case       :				List[Any] 			=    sorted(_validate_input(__SCREAMING_SNAKE_CASE   )   )
    __snake_case       :				Optional[Any] 			=    len(__SCREAMING_SNAKE_CASE   )
    __snake_case       :				Dict 			=    set()

    for i in range(n - 1   ):
        for j in range(i + 1		,							__SCREAMING_SNAKE_CASE   ):
            __snake_case       :				str 			=    False
            __snake_case       :				Any 			=    True
            for k in range(__SCREAMING_SNAKE_CASE   ):
                if k != i and k != j:
                    __snake_case       :				str 			=    _det(points[i]		,							points[j]		,							points[k]   )

                    if det_k > 0:
                        __snake_case       :				str 			=    True
                    elif det_k < 0:
                        __snake_case       :				List[Any] 			=    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]:
                            __snake_case       :				Any 			=    False
                            break

                if points_left_of_ij and points_right_of_ij:
                    __snake_case       :				int 			=    False
                    break

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

    return sorted(__SCREAMING_SNAKE_CASE   )







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point]   ):







    '''simple docstring'''
    __snake_case       :				Union[str, Any] 			=    sorted(_validate_input(__SCREAMING_SNAKE_CASE   )   )
    __snake_case       :				Any 			=    len(__SCREAMING_SNAKE_CASE   )

    # 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

    __snake_case       :				Tuple 			=    points[0]
    __snake_case       :				Optional[Any] 			=    points[n - 1]

    __snake_case       :				Optional[Any] 			=    {left_most_point, right_most_point}
    __snake_case       :				Optional[int] 			=    []
    __snake_case       :				List[str] 			=    []

    for i in range(1		,							n - 1   ):
        __snake_case       :				Tuple 			=    _det(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							points[i]   )

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

    _construct_hull(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   )
    _construct_hull(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   )

    return sorted(__SCREAMING_SNAKE_CASE   )







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point]		,							__SCREAMING_SNAKE_CASE       :					Point		,							__SCREAMING_SNAKE_CASE       :					Point		,							__SCREAMING_SNAKE_CASE       :					set[Point]   ):







    '''simple docstring'''
    if points:
        __snake_case       :				List[str] 			=    None
        __snake_case       :				Tuple 			=    float("""-inf"""   )
        __snake_case       :				List[Any] 			=    []

        for p in points:
            __snake_case       :				Union[str, Any] 			=    _det(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   )

            if det > 0:
                candidate_points.append(__SCREAMING_SNAKE_CASE   )

                if det > extreme_point_distance:
                    __snake_case       :				List[str] 			=    det
                    __snake_case       :				List[str] 			=    p

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







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					list[Point]   ):







    '''simple docstring'''
    __snake_case       :				Tuple 			=    sorted(_validate_input(__SCREAMING_SNAKE_CASE   )   )
    __snake_case       :				str 			=    len(__SCREAMING_SNAKE_CASE   )

    __snake_case       :				Optional[int] 			=    points[:2]
    for i in range(2		,							__SCREAMING_SNAKE_CASE   ):
        __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:
            __snake_case       :				Union[str, Any] 			=    points[i]
    i += 1

    for j in range(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   ):
        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(__SCREAMING_SNAKE_CASE   ) > 3 else convex_hull   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    __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)]
    __snake_case       :				Optional[Any] 			=    convex_hull_bf(__SCREAMING_SNAKE_CASE   )

    __snake_case       :				List[Any] 			=    convex_hull_recursive(__SCREAMING_SNAKE_CASE   )
    assert results_bf == results_recursive

    __snake_case       :				Tuple 			=    convex_hull_melkman(__SCREAMING_SNAKE_CASE   )
    assert results_bf == results_melkman

    print(__SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
     main()



