
from copy import deepcopy
from unittest.case import TestCase

import pytest

from datasets.arrow_dataset import Dataset
from datasets.features import Audio, ClassLabel, Features, Image, Sequence, Value
from datasets.info import DatasetInfo
from datasets.tasks import (
    AudioClassification,
    AutomaticSpeechRecognition,
    ImageClassification,
    LanguageModeling,
    QuestionAnsweringExtractive,
    Summarization,
    TextClassification,
    task_template_from_dict,
)
from datasets.utils.py_utils import asdict


__UpperCAmelCase   						=     {
    "id": "5733be284776f41900661182",
    "title": "University_of_Notre_Dame",
    "context": "Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend \"Venite Ad Me Omnes\". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive (and in a direct line that connects through 3 statues and the Gold Dome), is a simple, modern stone statue of Mary.",
    "question": "To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?",
    "answers": {"text": ["Saint Bernadette Soubirous"], "answer_start": [5_15]},
}


@pytest.mark.parametrize(
    '''task_cls''',  [
        AudioClassification,
        AutomaticSpeechRecognition,
        ImageClassification,
        LanguageModeling,
        QuestionAnsweringExtractive,
        Summarization,
        TextClassification,
    ],  )
def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      task_cls()
   SCREAMING_SNAKE_CASE_	=      asdict(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      task_template_from_dict(__lowerCamelCase						)
   assert task == reloaded





class 				UpperCamelCase__		:






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				List[Any]:
          SCREAMING_SNAKE_CASE_	=      LanguageModeling(text_column='''input_text'''	)
          assert {"input_text": "text"} == task.column_mapping




       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      Features({'''text''': Value('''string'''	)}	)
          SCREAMING_SNAKE_CASE_	=      {'''text_column''': '''input_text'''}
          SCREAMING_SNAKE_CASE_	=      LanguageModeling.from_dict(_A	)
          assert "language-modeling" == task.task
          assert input_schema == task.input_schema







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				List[Any]:
          SCREAMING_SNAKE_CASE_	=      sorted(['''pos''', '''neg''']	)



       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      TextClassification(text_column='''input_text''' ,     label_column='''input_label'''	)
          self.assertDictEqual({'''input_text''': '''text''', '''input_label''': '''labels'''} ,     task.column_mapping	)



       def     _UpperCamelCase	(							self	)				->				int:
          SCREAMING_SNAKE_CASE_	=      Features({'''text''': Value('''string'''	)}	)
          # Labels are cast to tuple during `TextClassification.__post_init__`, so we do the same here
          SCREAMING_SNAKE_CASE_	=      Features({'''labels''': ClassLabel}	)
          SCREAMING_SNAKE_CASE_	=      {'''text_column''': '''input_text''', '''label_column''': '''input_labels'''}
          SCREAMING_SNAKE_CASE_	=      TextClassification.from_dict(_A	)
          self.assertEqual('''text-classification''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)




       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      TextClassification(text_column='''input_text''' ,     label_column='''input_label'''	)
          self.assertEqual(task.label_schema['''labels'''] ,     _A	)
          SCREAMING_SNAKE_CASE_	=      task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels	)}	)	)
          self.assertEqual(task.label_schema['''labels'''] ,     ClassLabel(names=self.labels	)	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				Any:
          SCREAMING_SNAKE_CASE_	=      QuestionAnsweringExtractive(
              context_column='''input_context''' ,     question_column='''input_question''' ,     answers_column='''input_answers'''	)
          self.assertDictEqual(
              {'''input_context''': '''context''', '''input_question''': '''question''', '''input_answers''': '''answers'''} ,     task.column_mapping	)




       def     _UpperCamelCase	(							self	)				->				Tuple:
          SCREAMING_SNAKE_CASE_	=      Features({'''question''': Value('''string'''	), '''context''': Value('''string'''	)}	)
          SCREAMING_SNAKE_CASE_	=      Features(
              {
                  '''answers''': Sequence(
                      {
                          '''text''': Value('''string'''	),
                          '''answer_start''': Value('''int32'''	),
                      }	)
              }	)
          SCREAMING_SNAKE_CASE_	=      {
              '''context_column''': '''input_input_context''',
              '''question_column''': '''input_question''',
              '''answers_column''': '''input_answers''',
          }
          SCREAMING_SNAKE_CASE_	=      QuestionAnsweringExtractive.from_dict(_A	)
          self.assertEqual('''question-answering-extractive''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				Tuple:
          SCREAMING_SNAKE_CASE_	=      Summarization(text_column='''input_text''' ,     summary_column='''input_summary'''	)
          self.assertDictEqual({'''input_text''': '''text''', '''input_summary''': '''summary'''} ,     task.column_mapping	)




       def     _UpperCamelCase	(							self	)				->				Tuple:
          SCREAMING_SNAKE_CASE_	=      Features({'''text''': Value('''string'''	)}	)
          SCREAMING_SNAKE_CASE_	=      Features({'''summary''': Value('''string'''	)}	)
          SCREAMING_SNAKE_CASE_	=      {'''text_column''': '''input_text''', '''summary_column''': '''input_summary'''}
          SCREAMING_SNAKE_CASE_	=      Summarization.from_dict(_A	)
          self.assertEqual('''summarization''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				List[str]:
          SCREAMING_SNAKE_CASE_	=      AutomaticSpeechRecognition(audio_column='''input_audio''' ,     transcription_column='''input_transcription'''	)
          self.assertDictEqual({'''input_audio''': '''audio''', '''input_transcription''': '''transcription'''} ,     task.column_mapping	)




       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      Features({'''audio''': Audio()}	)
          SCREAMING_SNAKE_CASE_	=      Features({'''transcription''': Value('''string'''	)}	)
          SCREAMING_SNAKE_CASE_	=      {
              '''audio_column''': '''input_audio''',
              '''transcription_column''': '''input_transcription''',
          }
          SCREAMING_SNAKE_CASE_	=      AutomaticSpeechRecognition.from_dict(_A	)
          self.assertEqual('''automatic-speech-recognition''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				Any:
          SCREAMING_SNAKE_CASE_	=      sorted(['''pos''', '''neg''']	)



       def     _UpperCamelCase	(							self	)				->				Tuple:
          SCREAMING_SNAKE_CASE_	=      AudioClassification(audio_column='''input_audio''' ,     label_column='''input_label'''	)
          self.assertDictEqual({'''input_audio''': '''audio''', '''input_label''': '''labels'''} ,     task.column_mapping	)



       def     _UpperCamelCase	(							self	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	=      Features({'''audio''': Audio()}	)
          SCREAMING_SNAKE_CASE_	=      Features({'''labels''': ClassLabel}	)
          SCREAMING_SNAKE_CASE_	=      {
              '''audio_column''': '''input_image''',
              '''label_column''': '''input_label''',
          }
          SCREAMING_SNAKE_CASE_	=      AudioClassification.from_dict(_A	)
          self.assertEqual('''audio-classification''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)




       def     _UpperCamelCase	(							self	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	=      AudioClassification(audio_column='''input_audio''' ,     label_column='''input_label'''	)
          self.assertEqual(task.label_schema['''labels'''] ,     _A	)
          SCREAMING_SNAKE_CASE_	=      task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels	)}	)	)
          self.assertEqual(task.label_schema['''labels'''] ,     ClassLabel(names=self.labels	)	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	=      sorted(['''pos''', '''neg''']	)



       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      ImageClassification(image_column='''input_image''' ,     label_column='''input_label'''	)
          self.assertDictEqual({'''input_image''': '''image''', '''input_label''': '''labels'''} ,     task.column_mapping	)



       def     _UpperCamelCase	(							self	)				->				List[Any]:
          SCREAMING_SNAKE_CASE_	=      Features({'''image''': Image()}	)
          SCREAMING_SNAKE_CASE_	=      Features({'''labels''': ClassLabel}	)
          SCREAMING_SNAKE_CASE_	=      {
              '''image_column''': '''input_image''',
              '''label_column''': '''input_label''',
          }
          SCREAMING_SNAKE_CASE_	=      ImageClassification.from_dict(_A	)
          self.assertEqual('''image-classification''' ,     task.task	)
          self.assertEqual(_A ,     task.input_schema	)
          self.assertEqual(_A ,     task.label_schema	)




       def     _UpperCamelCase	(							self	)				->				Dict:
          SCREAMING_SNAKE_CASE_	=      ImageClassification(image_column='''input_image''' ,     label_column='''input_label'''	)
          self.assertEqual(task.label_schema['''labels'''] ,     _A	)
          SCREAMING_SNAKE_CASE_	=      task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels	)}	)	)
          self.assertEqual(task.label_schema['''labels'''] ,     ClassLabel(names=self.labels	)	)







class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       def     _UpperCamelCase	(							self	)				->				Optional[int]:
          SCREAMING_SNAKE_CASE_	=      DatasetInfo(task_templates=QuestionAnsweringExtractive()	)
          SCREAMING_SNAKE_CASE_	=      Dataset.from_dict({k: [v] for k, v in SAMPLE_QUESTION_ANSWERING_EXTRACTIVE.items()} ,     info=_A	)
          assert isinstance(dataset.info.task_templates ,     _A	)
          assert len(dataset.info.task_templates	) == 1

          def keep_task(_A	):
             return x

          def dont_keep_task(_A	):
             SCREAMING_SNAKE_CASE_	=      deepcopy(_A	)
             SCREAMING_SNAKE_CASE_	=      0
             return out

          SCREAMING_SNAKE_CASE_	=      dataset.map(_A	)
          assert mapped_dataset.info.task_templates == dataset.info.task_templates
          # reload from cache
          SCREAMING_SNAKE_CASE_	=      dataset.map(_A	)
          assert mapped_dataset.info.task_templates == dataset.info.task_templates

          SCREAMING_SNAKE_CASE_	=      dataset.map(_A	)
          assert mapped_dataset.info.task_templates == []
          # reload from cache
          SCREAMING_SNAKE_CASE_	=      dataset.map(_A	)
          assert mapped_dataset.info.task_templates == []




       def     _UpperCamelCase	(							self	)				->				List[str]:
          SCREAMING_SNAKE_CASE_	=      Features({'''text''': Value('''string'''	), '''label''': ClassLabel(names=('''pos''', '''neg''')	)}	)
          SCREAMING_SNAKE_CASE_	=      TextClassification(text_column='''text''' ,     label_column='''label'''	)
          SCREAMING_SNAKE_CASE_	=      DatasetInfo(features=_A ,     task_templates=_A	)
          SCREAMING_SNAKE_CASE_	=      Dataset.from_dict({'''text''': ['''A sentence.'''], '''label''': ['''pos''']} ,     info=_A	)

          def process(_A	):
             return example

          SCREAMING_SNAKE_CASE_	=      dataset.remove_columns('''label'''	)
          SCREAMING_SNAKE_CASE_	=      modified_dataset.map(_A	)
          assert mapped_dataset.info.task_templates == []




from __future__ import annotations

from collections.abc import Iterable





class 				UpperCamelCase__		:






       """simple docstring"""


       def __init__(							self ,     _A ,     _A	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      float(_A	), float(_A	)



       def __eq__(							self ,     _A	)				->				str:
          return self.x == other.x and self.y == other.y



       def __ne__(							self ,     _A	)				->				Any:
          return not self == other



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



       def __lt__(							self ,     _A	)				->				Optional[int]:
          return not self > other



       def __ge__(							self ,     _A	)				->				int:
          if self.x > other.x:
             return True
          elif self.x == other.x:
             return self.y >= other.y
          return False



       def __le__(							self ,     _A	)				->				str:
          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  A__ (       __lowerCamelCase,  ):
   SCREAMING_SNAKE_CASE_	=      []
   if list_of_tuples:
      for p in list_of_tuples:
         if isinstance(__lowerCamelCase,  __lowerCamelCase						):
            points.append(__lowerCamelCase						)
         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  A__ (       __lowerCamelCase						):

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

   if not points:
      SCREAMING_SNAKE_CASE_	=      F'''Expecting a list of points but got {points}'''
      raise ValueError(__lowerCamelCase						)

   return _construct_points(__lowerCamelCase						)


def  A__ (       __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      (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  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      set()

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

               if det_k > 0:
                  SCREAMING_SNAKE_CASE_	=      True
               elif det_k < 0:
                  SCREAMING_SNAKE_CASE_	=      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_	=      False
                     break

            if points_left_of_ij and points_right_of_ij:
               SCREAMING_SNAKE_CASE_	=      False
               break

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

   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)

   # 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_	=      points[0]
   SCREAMING_SNAKE_CASE_	=      points[n - 1]

   SCREAMING_SNAKE_CASE_	=      {left_most_point, right_most_point}
   SCREAMING_SNAKE_CASE_	=      []
   SCREAMING_SNAKE_CASE_	=      []

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

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

   _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)
   _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)

   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						):
   if points:
      SCREAMING_SNAKE_CASE_	=      None
      SCREAMING_SNAKE_CASE_	=      float('''-inf'''						)
      SCREAMING_SNAKE_CASE_	=      []

      for p in points:
         SCREAMING_SNAKE_CASE_	=      _det(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)

         if det > 0:
            candidate_points.append(__lowerCamelCase						)

            if det > extreme_point_distance:
               SCREAMING_SNAKE_CASE_	=      det
               SCREAMING_SNAKE_CASE_	=      p

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


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)

   SCREAMING_SNAKE_CASE_	=      points[:2]
   for i in range(2,  __lowerCamelCase						):
      SCREAMING_SNAKE_CASE_	=      _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_	=      points[i]
   i += 1

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


def  A__ (       ):
   SCREAMING_SNAKE_CASE_	=      [
       (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_	=      convex_hull_bf(__lowerCamelCase						)

   SCREAMING_SNAKE_CASE_	=      convex_hull_recursive(__lowerCamelCase						)
   assert results_bf == results_recursive

   SCREAMING_SNAKE_CASE_	=      convex_hull_melkman(__lowerCamelCase						)
   assert results_bf == results_melkman

   print(__lowerCamelCase						)


if __name__ == "__main__":
   main()


