




'''simple docstring'''
from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


A							:				Dict			     =	getLogger(__name__)


A							:				Tuple			     =	4
A							:				Optional[Any]			     =	7

A							:				Dict			     =	{
    """float16""": torch.floataa,
    """float32""": torch.floataa,
}
def     snake_case_  (       a__		:     Any      ):



    """simple docstring"""




    if isinstance(_lowerCAmelCase   ,torch.Tensor      ):
        return image
    elif isinstance(_lowerCAmelCase   ,PIL.Image.Image      ):
        __lowercase      =						[image]

    if isinstance(image[0]   ,PIL.Image.Image      ):
        __lowercase,__lowercase      =						image[0].size
        __lowercase,__lowercase      =						(x - x % 64 for x in (w, h))  # resize to integer multiple of 32

        __lowercase      =						[np.array(i.resize((w, h)      )      )[None, :] for i in image]
        __lowercase      =						np.concatenate(_lowerCAmelCase   ,axis=0      )
        __lowercase      =						np.array(_lowerCAmelCase      ).astype(np.floataa      ) / 2_5_5.0
        __lowercase      =						image.transpose(0   ,3   ,1   ,2      )
        __lowercase      =						2.0 * image - 1.0
        __lowercase      =						torch.from_numpy(_lowerCAmelCase      )
    elif isinstance(image[0]   ,torch.Tensor      ):
        __lowercase      =						torch.cat(_lowerCAmelCase   ,dim=0      )

    return image






class 	SCREAMING_SNAKE_CASE(    A__					):

       def __init__(   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ = 350 ,		)   -> List[str]:

           """simple docstring"""



           super().__init__(
               vae=snake_case_ ,		text_encoder=snake_case_ ,		tokenizer=snake_case_ ,		unet=snake_case_ ,		low_res_scheduler=snake_case_ ,		scheduler=snake_case_ ,		safety_checker=snake_case_ ,		feature_extractor=snake_case_ ,		watermarker=snake_case_ ,		max_noise_level=snake_case_ ,		)

       def __call__(   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ = 75 ,		lowerCamelCase__ = 9.0 ,		lowerCamelCase__ = 20 ,		lowerCamelCase__ = None ,		lowerCamelCase__ = 1 ,		lowerCamelCase__ = 0.0 ,		lowerCamelCase__ = None ,		lowerCamelCase__ = None ,		lowerCamelCase__ = None ,		lowerCamelCase__ = None ,		lowerCamelCase__ = "pil" ,		lowerCamelCase__ = True ,		lowerCamelCase__ = None ,		lowerCamelCase__ = 1 ,		)   -> Any:

           """simple docstring"""



           self.check_inputs(snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_					)

           # 2. Define call parameters
           if prompt is not None and isinstance(snake_case_ ,		snake_case_					):
               __lowercase      =						1
           elif prompt is not None and isinstance(snake_case_ ,		snake_case_					):
               __lowercase      =						len(snake_case_					)
           else:
               __lowercase      =						prompt_embeds.shape[0]

           __lowercase      =						self._execution_device
           # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
           # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
           # corresponds to doing no classifier free guidance.
           __lowercase      =						guidance_scale > 1.0

           # 3. Encode input prompt
           __lowercase      =						self._encode_prompt(
               snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		prompt_embeds=snake_case_ ,		negative_prompt_embeds=snake_case_ ,		)

           __lowercase      =						ORT_TO_PT_TYPE[str(text_embeddings.dtype					)]

           # 4. Preprocess image
           __lowercase      =						preprocess(snake_case_					)
           __lowercase      =						image.cpu()

           # 5. set timesteps
           self.scheduler.set_timesteps(snake_case_ ,		device=snake_case_					)
           __lowercase      =						self.scheduler.timesteps

           # 5. Add noise to image
           __lowercase      =						torch.tensor([noise_level] ,		dtype=torch.long ,		device=snake_case_					)
           __lowercase      =						torch.randn(image.shape ,		generator=snake_case_ ,		device=snake_case_ ,		dtype=snake_case_					)
           __lowercase      =						self.low_res_scheduler.add_noise(snake_case_ ,		snake_case_ ,		snake_case_					)

           __lowercase      =						2 if do_classifier_free_guidance else 1
           __lowercase      =						np.concatenate([image] * batch_multiplier * num_images_per_prompt					)
           __lowercase      =						np.concatenate([noise_level] * image.shape[0]					)

           # 6. Prepare latent variables
           __lowercase,__lowercase      =						image.shape[2:]
           __lowercase      =						self.prepare_latents(
               batch_size * num_images_per_prompt ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		snake_case_ ,		)

           # 7. Check that sizes of image and latents match
           __lowercase      =						image.shape[1]
           if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
               raise ValueError(
                   """Incorrect configuration settings! The config of `pipeline.unet` expects"""
                   F' {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +'
                   F' `num_channels_image`: {num_channels_image} '
                   F' = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of'
                   """ `pipeline.unet` or your `image` input."""					)

           # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
           __lowercase      =						self.prepare_extra_step_kwargs(snake_case_ ,		snake_case_					)

           __lowercase      =						next(
               (input.type for input in self.unet.model.get_inputs() if input.name == """timestep""") ,		"""tensor(float)"""					)
           __lowercase      =						ORT_TO_NP_TYPE[timestep_dtype]

           # 9. Denoising loop
           __lowercase      =						len(snake_case_					) - num_inference_steps * self.scheduler.order
           with self.progress_bar(total=snake_case_					) as progress_bar:
               for i, t in enumerate(snake_case_					):
                   # expand the latents if we are doing classifier free guidance
                   __lowercase      =						np.concatenate([latents] * 2					) if do_classifier_free_guidance else latents

                   # concat latents, mask, masked_image_latents in the channel dimension
                   __lowercase      =						self.scheduler.scale_model_input(snake_case_ ,		snake_case_					)
                   __lowercase      =						np.concatenate([latent_model_input, image] ,		axis=1					)

                   # timestep to tensor
                   __lowercase      =						np.array([t] ,		dtype=snake_case_					)

                   # predict the noise residual
                   __lowercase      =						self.unet(
                       sample=snake_case_ ,		timestep=snake_case_ ,		encoder_hidden_states=snake_case_ ,		class_labels=noise_level.astype(np.intaa					) ,		)[0]

                   # perform guidance
                   if do_classifier_free_guidance:
                       __lowercase,__lowercase      =						np.split(snake_case_ ,		2					)
                   __lowercase      =						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                   # compute the previous noisy sample x_t -> x_t-1
                   __lowercase      =						self.scheduler.step(
                       torch.from_numpy(snake_case_					) ,		snake_case_ ,		snake_case_ ,		**snake_case_					).prev_sample

                   # call the callback, if provided
                   if i == len(snake_case_					) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
                       progress_bar.update()
                       if callback is not None and i % callback_steps == 0:
                           callback(snake_case_ ,		snake_case_ ,		snake_case_					)

        # 10. Post-processing
           __lowercase      =						self.decode_latents(latents.float()					)

           # 11. Convert to PIL
           if output_type == "pil":
               __lowercase      =						self.numpy_to_pil(snake_case_					)

           if not return_dict:
               return (image,)

           return ImagePipelineOutput(images=snake_case_					)

       def    snake_case__      (   self ,		lowerCamelCase__					)   -> Dict:

           """simple docstring"""



           __lowercase      =						1 / 0.0_83_33 * latents
           __lowercase      =						self.vae(latent_sample=snake_case_					)[0]
           __lowercase      =						np.clip(image / 2 + 0.5 ,		0 ,		1					)
           __lowercase      =						image.transpose((0, 2, 3, 1)					)
           return image




       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ = None ,		lowerCamelCase__ = None ,		)   -> List[str]:

           """simple docstring"""



           if prompt is not None and isinstance(snake_case_ ,		snake_case_					):
               __lowercase      =						1
           elif prompt is not None and isinstance(snake_case_ ,		snake_case_					):
               __lowercase      =						len(snake_case_					)
           else:
               __lowercase      =						prompt_embeds.shape[0]

           if prompt_embeds is None:
               __lowercase      =						self.tokenizer(
                   snake_case_ ,		padding="""max_length""" ,		max_length=self.tokenizer.model_max_length ,		truncation=snake_case_ ,		return_tensors="""pt""" ,		)
               __lowercase      =						text_inputs.input_ids
               __lowercase      =						self.tokenizer(snake_case_ ,		padding="""longest""" ,		return_tensors="""pt"""					).input_ids

               if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
                   snake_case_ ,		snake_case_					):
                   __lowercase      =						self.tokenizer.batch_decode(
                       untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]					)
                   logger.warning(
                       """The following part of your input was truncated because CLIP can only handle sequences up to"""
                       F' {self.tokenizer.model_max_length} tokens: {removed_text}'					)

               # no positional arguments to text_encoder
               __lowercase      =						self.text_encoder(
                   input_ids=text_input_ids.int().to(snake_case_					) ,		)
               __lowercase      =						prompt_embeds[0]

           __lowercase,__lowercase,__lowercase      =						prompt_embeds.shape
           # duplicate text embeddings for each generation per prompt, using mps friendly method
           __lowercase      =						prompt_embeds.repeat(1 ,		snake_case_					)
           __lowercase      =						prompt_embeds.reshape(bs_embed * num_images_per_prompt ,		snake_case_ ,		-1					)

           # get unconditional embeddings for classifier free guidance
           if do_classifier_free_guidance and negative_prompt_embeds is None:
               __lowercase      =						42
               if negative_prompt is None:
                   __lowercase      =						[""""""] * batch_size
               elif type(snake_case_					) is not type(snake_case_					):
                   raise TypeError(
                       F'`negative_prompt` should be the same type to `prompt`, but got {type(snake_case_					)} !='
                       F' {type(snake_case_					)}.'					)
               elif isinstance(snake_case_ ,		snake_case_					):
                   __lowercase      =						[negative_prompt]
               elif batch_size != len(snake_case_					):
                   raise ValueError(
                       F'`negative_prompt`: {negative_prompt} has batch size {len(snake_case_					)}, but `prompt`:'
                       F' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
                       """ the batch size of `prompt`."""					)
               else:
                   __lowercase      =						negative_prompt

               __lowercase      =						text_input_ids.shape[-1]
               __lowercase      =						self.tokenizer(
                   snake_case_ ,		padding="""max_length""" ,		max_length=snake_case_ ,		truncation=snake_case_ ,		return_tensors="""pt""" ,		)

               # if hasattr(uncond_input, "attention_mask"):
               #     attention_mask = uncond_input.attention_mask.to(device)
               # else:
               #     attention_mask = None

               __lowercase      =						self.text_encoder(
                   input_ids=uncond_input.input_ids.int().to(snake_case_					) ,		)
               __lowercase      =						uncond_embeddings[0]

           if do_classifier_free_guidance:
               __lowercase      =						uncond_embeddings.shape[1]
               # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
               __lowercase      =						uncond_embeddings.repeat(1 ,		snake_case_					)
               __lowercase      =						uncond_embeddings.reshape(batch_size * num_images_per_prompt ,		snake_case_ ,		-1					)

               # For classifier free guidance, we need to do two forward passes.
               # Here we concatenate the unconditional and text embeddings into a single batch
               # to avoid doing two forward passes
               __lowercase      =						np.concatenate([uncond_embeddings, prompt_embeds]					)

           return prompt_embeds










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


A							:				Dict			     =	{
    """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     snake_case_  (       a__		:     str      ):



    """simple docstring"""




    __lowercase          =						task_cls()
    __lowercase          =						asdict(a__      )
    __lowercase          =						task_template_from_dict(a__      )
    assert task == reloaded






class 	SCREAMING_SNAKE_CASE:

       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



           __lowercase          =						LanguageModeling(text_column="""input_text"""					)
           assert {"input_text": "text"} == task.column_mapping




       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



           __lowercase          =						Features({"""text""": Value("""string"""					)}					)
           __lowercase          =						{"""text_column""": """input_text"""}
           __lowercase          =						LanguageModeling.from_dict(lowerCamelCase__					)
           assert "language-modeling" == task.task
           assert input_schema == task.input_schema






class 	SCREAMING_SNAKE_CASE(    __A					):

       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           __lowercase          =						sorted(["""pos""", """neg"""]					)

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						TextClassification(text_column="""input_text""" ,		label_column="""input_label"""					)
           self.assertDictEqual({"""input_text""": """text""", """input_label""": """labels"""} ,		task.column_mapping					)

       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



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




       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



           __lowercase          =						TextClassification(text_column="""input_text""" ,		label_column="""input_label"""					)
           self.assertEqual(task.label_schema["""labels"""] ,		lowerCamelCase__					)
           __lowercase          =						task.align_with_features(Features({"""input_label""": ClassLabel(names=self.labels					)}					)					)
           self.assertEqual(task.label_schema["""labels"""] ,		ClassLabel(names=self.labels					)					)






class 	SCREAMING_SNAKE_CASE(    __A					):

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

           """simple docstring"""



           __lowercase          =						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    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           __lowercase          =						Features({"""question""": Value("""string"""					), """context""": Value("""string"""					)}					)
           __lowercase          =						Features(
               {
                   """answers""": Sequence(
                       {
                           """text""": Value("""string"""					),
                           """answer_start""": Value("""int32"""					),
                       }					)
               }					)
           __lowercase          =						{
               """context_column""": """input_input_context""",
               """question_column""": """input_question""",
               """answers_column""": """input_answers""",
           }
           __lowercase          =						QuestionAnsweringExtractive.from_dict(lowerCamelCase__					)
           self.assertEqual("""question-answering-extractive""" ,		task.task					)
           self.assertEqual(lowerCamelCase__ ,		task.input_schema					)
           self.assertEqual(lowerCamelCase__ ,		task.label_schema					)






class 	SCREAMING_SNAKE_CASE(    __A					):

       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



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




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

           """simple docstring"""



           __lowercase          =						Features({"""text""": Value("""string"""					)}					)
           __lowercase          =						Features({"""summary""": Value("""string"""					)}					)
           __lowercase          =						{"""text_column""": """input_text""", """summary_column""": """input_summary"""}
           __lowercase          =						Summarization.from_dict(lowerCamelCase__					)
           self.assertEqual("""summarization""" ,		task.task					)
           self.assertEqual(lowerCamelCase__ ,		task.input_schema					)
           self.assertEqual(lowerCamelCase__ ,		task.label_schema					)






class 	SCREAMING_SNAKE_CASE(    __A					):

       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



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




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

           """simple docstring"""



           __lowercase          =						Features({"""audio""": Audio()}					)
           __lowercase          =						Features({"""transcription""": Value("""string"""					)}					)
           __lowercase          =						{
               """audio_column""": """input_audio""",
               """transcription_column""": """input_transcription""",
           }
           __lowercase          =						AutomaticSpeechRecognition.from_dict(lowerCamelCase__					)
           self.assertEqual("""automatic-speech-recognition""" ,		task.task					)
           self.assertEqual(lowerCamelCase__ ,		task.input_schema					)
           self.assertEqual(lowerCamelCase__ ,		task.label_schema					)






class 	SCREAMING_SNAKE_CASE(    __A					):

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						sorted(["""pos""", """neg"""]					)

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

           """simple docstring"""



           __lowercase          =						AudioClassification(audio_column="""input_audio""" ,		label_column="""input_label"""					)
           self.assertDictEqual({"""input_audio""": """audio""", """input_label""": """labels"""} ,		task.column_mapping					)

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

           """simple docstring"""



           __lowercase          =						Features({"""audio""": Audio()}					)
           __lowercase          =						Features({"""labels""": ClassLabel}					)
           __lowercase          =						{
               """audio_column""": """input_image""",
               """label_column""": """input_label""",
           }
           __lowercase          =						AudioClassification.from_dict(lowerCamelCase__					)
           self.assertEqual("""audio-classification""" ,		task.task					)
           self.assertEqual(lowerCamelCase__ ,		task.input_schema					)
           self.assertEqual(lowerCamelCase__ ,		task.label_schema					)




       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



           __lowercase          =						AudioClassification(audio_column="""input_audio""" ,		label_column="""input_label"""					)
           self.assertEqual(task.label_schema["""labels"""] ,		lowerCamelCase__					)
           __lowercase          =						task.align_with_features(Features({"""input_label""": ClassLabel(names=self.labels					)}					)					)
           self.assertEqual(task.label_schema["""labels"""] ,		ClassLabel(names=self.labels					)					)






class 	SCREAMING_SNAKE_CASE(    __A					):

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

           """simple docstring"""



           __lowercase          =						sorted(["""pos""", """neg"""]					)

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

           """simple docstring"""



           __lowercase          =						ImageClassification(image_column="""input_image""" ,		label_column="""input_label"""					)
           self.assertDictEqual({"""input_image""": """image""", """input_label""": """labels"""} ,		task.column_mapping					)

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

           """simple docstring"""



           __lowercase          =						Features({"""image""": Image()}					)
           __lowercase          =						Features({"""labels""": ClassLabel}					)
           __lowercase          =						{
               """image_column""": """input_image""",
               """label_column""": """input_label""",
           }
           __lowercase          =						ImageClassification.from_dict(lowerCamelCase__					)
           self.assertEqual("""image-classification""" ,		task.task					)
           self.assertEqual(lowerCamelCase__ ,		task.input_schema					)
           self.assertEqual(lowerCamelCase__ ,		task.label_schema					)




       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



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






class 	SCREAMING_SNAKE_CASE(    __A					):

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						DatasetInfo(task_templates=QuestionAnsweringExtractive()					)
           __lowercase          =						Dataset.from_dict({k: [v] for k, v in SAMPLE_QUESTION_ANSWERING_EXTRACTIVE.items()} ,		info=lowerCamelCase__					)
           assert isinstance(dataset.info.task_templates ,		lowerCamelCase__					)
           assert len(dataset.info.task_templates					) == 1

           def keep_task(lowerCamelCase__					):
               return x

           def dont_keep_task(lowerCamelCase__					):
               __lowercase          =						deepcopy(lowerCamelCase__					)
               __lowercase          =						0
               return out

           __lowercase          =						dataset.map(lowerCamelCase__					)
           assert mapped_dataset.info.task_templates == dataset.info.task_templates
           # reload from cache
           __lowercase          =						dataset.map(lowerCamelCase__					)
           assert mapped_dataset.info.task_templates == dataset.info.task_templates

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




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

           """simple docstring"""



           __lowercase          =						Features({"""text""": Value("""string"""					), """label""": ClassLabel(names=("""pos""", """neg""")					)}					)
           __lowercase          =						TextClassification(text_column="""text""" ,		label_column="""label"""					)
           __lowercase          =						DatasetInfo(features=lowerCamelCase__ ,		task_templates=lowerCamelCase__					)
           __lowercase          =						Dataset.from_dict({"""text""": ["""A sentence."""], """label""": ["""pos"""]} ,		info=lowerCamelCase__					)

           def process(lowerCamelCase__					):
               return example

           __lowercase          =						dataset.remove_columns("""label"""					)
           __lowercase          =						modified_dataset.map(lowerCamelCase__					)
           assert mapped_dataset.info.task_templates == []




