





'''simple docstring'''


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


lowerCAmelCase      :  Tuple      							={
    '''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''': [515]},
}
@pytest.mark.parametrize(
    "task_cls"			,[
        AudioClassification,
        AutomaticSpeechRecognition,
        ImageClassification,
        LanguageModeling,
        QuestionAnsweringExtractive,
        Summarization,
        TextClassification,
    ]			,)
def 							UpperCAmelCase_						(		__lowerCamelCase      :      str				):
   lowercase_    :str					    =				task_cls()
   lowercase_    :Tuple					    =				asdict(__lowerCamelCase				)
   lowercase_    :Dict					    =				task_template_from_dict(__lowerCamelCase				)
   assert task == reloaded
class    a_     :





     def 							lowercase__   (				self	:      Optional[Any]		):





        """simple docstring"""




        lowercase_    :Optional[int]					    =				LanguageModeling(text_column="input_text"		)
        assert {"input_text": "text"} == task.column_mapping







     def 							lowercase__   (				self	:      Any		):





        """simple docstring"""




        lowercase_    :Tuple					    =				Features({"text": Value("string"		)}		)
        lowercase_    :List[Any]					    =				{"text_column": "input_text"}
        lowercase_    :List[str]					    =				LanguageModeling.from_dict(lowercase		)
        assert "language-modeling" == task.task
        assert input_schema == task.input_schema







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      Tuple		):





        """simple docstring"""




        lowercase_    :List[str]					    =				sorted(["pos", "neg"]		)





     def 							lowercase__   (				self	:      int		):





        """simple docstring"""




        lowercase_    :List[str]					    =				TextClassification(text_column="input_text"			,   label_column="input_label"		)
        self.assertDictEqual({"input_text": "text", "input_label": "labels"}			,   task.column_mapping		)





     def 							lowercase__   (				self	:      List[Any]		):





        """simple docstring"""




        lowercase_    :Union[str, Any]					    =				Features({"text": Value("string"		)}		)
        # Labels are cast to tuple during `TextClassification.__post_init__`, so we do the same here
        lowercase_    :Any					    =				Features({"labels": ClassLabel}		)
        lowercase_    :str					    =				{"text_column": "input_text", "label_column": "input_labels"}
        lowercase_    :Optional[int]					    =				TextClassification.from_dict(lowercase		)
        self.assertEqual("text-classification"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







     def 							lowercase__   (				self	:      str		):





        """simple docstring"""




        lowercase_    :Union[str, Any]					    =				TextClassification(text_column="input_text"			,   label_column="input_label"		)
        self.assertEqual(task.label_schema["labels"]			,   lowercase		)
        lowercase_    :Tuple					    =				task.align_with_features(Features({"input_label": ClassLabel(names=self.labels		)}		)		)
        self.assertEqual(task.label_schema["labels"]			,   ClassLabel(names=self.labels		)		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      List[str]		):





        """simple docstring"""




        lowercase_    :int					    =				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 							lowercase__   (				self	:      Any		):





        """simple docstring"""




        lowercase_    :Dict					    =				Features({"question": Value("string"		), "context": Value("string"		)}		)
        lowercase_    :List[Any]					    =				Features(
            {
                "answers": Sequence(
                    {
                        "text": Value("string"		),
                        "answer_start": Value("int32"		),
                    }		)
            }		)
        lowercase_    :int					    =				{
            "context_column": "input_input_context",
            "question_column": "input_question",
            "answers_column": "input_answers",
        }
        lowercase_    :int					    =				QuestionAnsweringExtractive.from_dict(lowercase		)
        self.assertEqual("question-answering-extractive"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      Any		):





        """simple docstring"""




        lowercase_    :Tuple					    =				Summarization(text_column="input_text"			,   summary_column="input_summary"		)
        self.assertDictEqual({"input_text": "text", "input_summary": "summary"}			,   task.column_mapping		)







     def 							lowercase__   (				self	:      Union[str, Any]		):





        """simple docstring"""




        lowercase_    :int					    =				Features({"text": Value("string"		)}		)
        lowercase_    :str					    =				Features({"summary": Value("string"		)}		)
        lowercase_    :Tuple					    =				{"text_column": "input_text", "summary_column": "input_summary"}
        lowercase_    :Optional[int]					    =				Summarization.from_dict(lowercase		)
        self.assertEqual("summarization"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      Any		):





        """simple docstring"""




        lowercase_    :Any					    =				AutomaticSpeechRecognition(audio_column="input_audio"			,   transcription_column="input_transcription"		)
        self.assertDictEqual({"input_audio": "audio", "input_transcription": "transcription"}			,   task.column_mapping		)







     def 							lowercase__   (				self	:      Optional[int]		):





        """simple docstring"""




        lowercase_    :Union[str, Any]					    =				Features({"audio": Audio()}		)
        lowercase_    :str					    =				Features({"transcription": Value("string"		)}		)
        lowercase_    :Dict					    =				{
            "audio_column": "input_audio",
            "transcription_column": "input_transcription",
        }
        lowercase_    :Tuple					    =				AutomaticSpeechRecognition.from_dict(lowercase		)
        self.assertEqual("automatic-speech-recognition"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      int		):





        """simple docstring"""




        lowercase_    :str					    =				sorted(["pos", "neg"]		)





     def 							lowercase__   (				self	:      List[str]		):





        """simple docstring"""




        lowercase_    :Optional[int]					    =				AudioClassification(audio_column="input_audio"			,   label_column="input_label"		)
        self.assertDictEqual({"input_audio": "audio", "input_label": "labels"}			,   task.column_mapping		)





     def 							lowercase__   (				self	:      Optional[Any]		):





        """simple docstring"""




        lowercase_    :int					    =				Features({"audio": Audio()}		)
        lowercase_    :Tuple					    =				Features({"labels": ClassLabel}		)
        lowercase_    :List[str]					    =				{
            "audio_column": "input_image",
            "label_column": "input_label",
        }
        lowercase_    :List[Any]					    =				AudioClassification.from_dict(lowercase		)
        self.assertEqual("audio-classification"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







     def 							lowercase__   (				self	:      Union[str, Any]		):





        """simple docstring"""




        lowercase_    :Dict					    =				AudioClassification(audio_column="input_audio"			,   label_column="input_label"		)
        self.assertEqual(task.label_schema["labels"]			,   lowercase		)
        lowercase_    :List[Any]					    =				task.align_with_features(Features({"input_label": ClassLabel(names=self.labels		)}		)		)
        self.assertEqual(task.label_schema["labels"]			,   ClassLabel(names=self.labels		)		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      Union[str, Any]		):





        """simple docstring"""




        lowercase_    :Union[str, Any]					    =				sorted(["pos", "neg"]		)





     def 							lowercase__   (				self	:      Any		):





        """simple docstring"""




        lowercase_    :Optional[int]					    =				ImageClassification(image_column="input_image"			,   label_column="input_label"		)
        self.assertDictEqual({"input_image": "image", "input_label": "labels"}			,   task.column_mapping		)





     def 							lowercase__   (				self	:      Optional[Any]		):





        """simple docstring"""




        lowercase_    :Dict					    =				Features({"image": Image()}		)
        lowercase_    :str					    =				Features({"labels": ClassLabel}		)
        lowercase_    :Optional[Any]					    =				{
            "image_column": "input_image",
            "label_column": "input_label",
        }
        lowercase_    :str					    =				ImageClassification.from_dict(lowercase		)
        self.assertEqual("image-classification"			,   task.task		)
        self.assertEqual(lowercase			,   task.input_schema		)
        self.assertEqual(lowercase			,   task.label_schema		)







     def 							lowercase__   (				self	:      List[Any]		):





        """simple docstring"""




        lowercase_    :Any					    =				ImageClassification(image_column="input_image"			,   label_column="input_label"		)
        self.assertEqual(task.label_schema["labels"]			,   lowercase		)
        lowercase_    :Dict					    =				task.align_with_features(Features({"input_label": ClassLabel(names=self.labels		)}		)		)
        self.assertEqual(task.label_schema["labels"]			,   ClassLabel(names=self.labels		)		)







class    a_     (       _lowerCAmelCase							):





     def 							lowercase__   (				self	:      Tuple		):





        """simple docstring"""




        lowercase_    :Dict					    =				DatasetInfo(task_templates=QuestionAnsweringExtractive()		)
        lowercase_    :Optional[Any]					    =				Dataset.from_dict({k: [v] for k, v in SAMPLE_QUESTION_ANSWERING_EXTRACTIVE.items()}			,   info=lowercase		)
        assert isinstance(dataset.info.task_templates			,   lowercase		)
        assert len(dataset.info.task_templates		) == 1

        def keep_task(lowercase	:      List[str]		):
           return x

        def dont_keep_task(lowercase	:      Any		):
           lowercase_    :Optional[Any]					    =				deepcopy(lowercase		)
           lowercase_    :Dict					    =				0
           return out

        lowercase_    :List[str]					    =				dataset.map(lowercase		)
        assert mapped_dataset.info.task_templates == dataset.info.task_templates
        # reload from cache
        lowercase_    :List[Any]					    =				dataset.map(lowercase		)
        assert mapped_dataset.info.task_templates == dataset.info.task_templates

        lowercase_    :str					    =				dataset.map(lowercase		)
        assert mapped_dataset.info.task_templates == []
        # reload from cache
        lowercase_    :Union[str, Any]					    =				dataset.map(lowercase		)
        assert mapped_dataset.info.task_templates == []







     def 							lowercase__   (				self	:      Optional[Any]		):





        """simple docstring"""




        lowercase_    :Optional[Any]					    =				Features({"text": Value("string"		), "label": ClassLabel(names=("pos", "neg")		)}		)
        lowercase_    :str					    =				TextClassification(text_column="text"			,   label_column="label"		)
        lowercase_    :Optional[int]					    =				DatasetInfo(features=lowercase			,   task_templates=lowercase		)
        lowercase_    :Dict					    =				Dataset.from_dict({"text": ["A sentence."], "label": ["pos"]}			,   info=lowercase		)

        def process(lowercase	:      Dict		):
           return example

        lowercase_    :Tuple					    =				dataset.remove_columns("label"		)
        lowercase_    :Optional[int]					    =				modified_dataset.map(lowercase		)
        assert mapped_dataset.info.task_templates == []









'''simple docstring'''


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
 import PIL


lowerCAmelCase      :  Any      							=logging.get_logger(__name__)
class    a_     (       _lowerCAmelCase							):
     __A  				=    ["pixel_values"]





     def __init__(				self	:      Tuple			,   lowercase	:      bool = True			,   lowercase	:      Dict[str, int] = None			,   lowercase	:      bool = True			,   lowercase	:      Dict[str, int] = None			,   lowercase	:      PILImageResampling = PILImageResampling.BICUBIC			,   lowercase	:      bool = True			,   lowercase	:      Union[int, float] = 1 / 255			,   lowercase	:      bool = True			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   **lowercase	:      int			,   ):





        """simple docstring"""




        super().__init__(**lowercase		)
        lowercase_    :Dict					    =				crop_size if crop_size is not None else {"height": 256, "width": 256}
        lowercase_    :str					    =				get_size_dict(lowercase			,   param_name="crop_size"		)
        lowercase_    :Optional[Any]					    =				size if size is not None else {"height": 224, "width": 224}
        lowercase_    :Union[str, Any]					    =				get_size_dict(lowercase		)

        lowercase_    :Union[str, Any]					    =				do_center_crop
        lowercase_    :str					    =				crop_size
        lowercase_    :List[str]					    =				do_resize
        lowercase_    :str					    =				size
        lowercase_    :Tuple					    =				resample
        lowercase_    :int					    =				do_rescale
        lowercase_    :Union[str, Any]					    =				rescale_factor
        lowercase_    :Tuple					    =				do_normalize
        lowercase_    :List[Any]					    =				image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
        lowercase_    :Optional[int]					    =				image_std if image_std is not None else IMAGENET_DEFAULT_STD





     def 							lowercase__   (				self	:      Any			,   lowercase	:      np.ndarray			,   lowercase	:      Dict[str, int]			,   lowercase	:      Optional[int] = None			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      List[Any]			,   ):





        """simple docstring"""




        lowercase_    :Dict					    =				self.size if size is None else size
        lowercase_    :Dict					    =				get_size_dict(lowercase		)
        lowercase_    :List[Any]					    =				get_size_dict(lowercase			,   param_name="crop_size"		)

        lowercase_    ,							lowercase_    :List[str]					    =				get_image_size(lowercase		)
        lowercase_    :List[str]					    =				min(lowercase			,   lowercase		)
        lowercase_    :Tuple					    =				(size["height"] / crop_size["height"]) * min_dim
        lowercase_    :int					    =				(size["width"] / crop_size["width"]) * min_dim
        return center_crop(lowercase			,   size=(cropped_height, cropped_width)			,   data_format=lowercase			,   **lowercase		)





     def 							lowercase__   (				self	:      Union[str, Any]			,   lowercase	:      np.ndarray			,   lowercase	:      Dict[str, int]			,   lowercase	:      PILImageResampling = PIL.Image.BICUBIC			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      List[str]			,   ):





        """simple docstring"""




        lowercase_    :Optional[int]					    =				get_size_dict(lowercase		)
        if "height" not in size or "width" not in size:
           raise ValueError(F'The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}'		)
        return resize(
            lowercase			,   size=(size["height"], size["width"])			,   resample=lowercase			,   data_format=lowercase			,   **lowercase		)





     def 							lowercase__   (				self	:      List[str]			,   lowercase	:      np.ndarray			,   lowercase	:      Union[int, float]			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      Union[str, Any]			,   ):





        """simple docstring"""




        return rescale(lowercase			,   scale=lowercase			,   data_format=lowercase			,   **lowercase		)





     def 							lowercase__   (				self	:      List[str]			,   lowercase	:      np.ndarray			,   lowercase	:      Union[float, List[float]]			,   lowercase	:      Union[float, List[float]]			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      str			,   ):





        """simple docstring"""




        return normalize(lowercase			,   mean=lowercase			,   std=lowercase			,   data_format=lowercase			,   **lowercase		)







     def 							lowercase__   (				self	:      List[Any]			,   lowercase	:      ImageInput			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Dict[str, int]] = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Dict[str, int]] = None			,   lowercase	:      PILImageResampling = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[float] = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   lowercase	:      Optional[Union[str, TensorType]] = None			,   lowercase	:      ChannelDimension = ChannelDimension.FIRST			,   **lowercase	:      Optional[Any]			,   ):





        """simple docstring"""




        lowercase_    :str					    =				do_center_crop if do_center_crop is not None else self.do_center_crop
        lowercase_    :Union[str, Any]					    =				crop_size if crop_size is not None else self.crop_size
        lowercase_    :Optional[Any]					    =				get_size_dict(lowercase			,   param_name="crop_size"		)
        lowercase_    :Union[str, Any]					    =				do_resize if do_resize is not None else self.do_resize
        lowercase_    :Any					    =				size if size is not None else self.size
        lowercase_    :List[Any]					    =				get_size_dict(lowercase		)
        lowercase_    :Optional[Any]					    =				resample if resample is not None else self.resample
        lowercase_    :Dict					    =				do_rescale if do_rescale is not None else self.do_rescale
        lowercase_    :List[Any]					    =				rescale_factor if rescale_factor is not None else self.rescale_factor
        lowercase_    :str					    =				do_normalize if do_normalize is not None else self.do_normalize
        lowercase_    :Dict					    =				image_mean if image_mean is not None else self.image_mean
        lowercase_    :List[Any]					    =				image_std if image_std is not None else self.image_std

        lowercase_    :Any					    =				make_list_of_images(lowercase		)

        if not valid_images(lowercase		):
           raise ValueError(
               "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
               "torch.Tensor, tf.Tensor or jax.ndarray."		)

        if do_center_crop and crop_size is None:
           raise ValueError("If `do_center_crop` is set to `True`, `crop_size` must be provided."		)

        if do_resize and size is None:
           raise ValueError("Size must be specified if do_resize is True."		)

        if do_rescale and rescale_factor is None:
           raise ValueError("Rescale factor must be specified if do_rescale is True."		)

        if do_normalize and (image_mean is None or image_std is None):
           raise ValueError("Image mean and image standard deviation must be specified if do_normalize is True."		)

        # All transformations expect numpy arrays.
        lowercase_    :Optional[int]					    =				[to_numpy_array(lowercase		) for image in images]

        if do_center_crop:
           lowercase_    :str					    =				[self.center_crop(lowercase			,   lowercase			,   size=lowercase		) for image in images]

        if do_resize:
           lowercase_    :List[str]					    =				[self.resize(image=lowercase			,   size=lowercase			,   resample=lowercase		) for image in images]

        if do_rescale:
           lowercase_    :List[Any]					    =				[self.rescale(image=lowercase			,   scale=lowercase		) for image in images]

        if do_normalize:
           lowercase_    :Optional[Any]					    =				[self.normalize(image=lowercase			,   mean=lowercase			,   std=lowercase		) for image in images]

        lowercase_    :Optional[Any]					    =				[to_channel_dimension_format(lowercase			,   lowercase		) for image in images]

        lowercase_    :Union[str, Any]					    =				{"pixel_values": images}
        return BatchFeature(data=lowercase			,   tensor_type=lowercase		)


