
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class UpperCAmelCase   (						unittest.TestCase   ):





   '''simple docstring'''


   @property
   def  __magic_name__				(					self     :							Dict     ):

      """simple docstring"""
      torch.manual_seed(0     )
      _A:  int					=       UNetaDModel(
          block_out_channels=(3_2, 6_4)			,			layers_per_block=2			,			sample_size=3_2			,			in_channels=3			,			out_channels=3			,			down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')			,			up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')			,			)
      return model


   @property
   def  __magic_name__				(					self     :							Tuple     ):

      """simple docstring"""
      torch.manual_seed(0     )
      _A:  Tuple					=       VQModel(
          block_out_channels=[3_2, 6_4]			,			in_channels=3			,			out_channels=3			,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']			,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']			,			latent_channels=3			,			)
      return model


   @property
   def  __magic_name__				(					self     :							Tuple     ):

      """simple docstring"""
      torch.manual_seed(0     )
      _A:  str					=       CLIPTextConfig(
          bos_token_id=0			,			eos_token_id=2			,			hidden_size=3_2			,			intermediate_size=3_7			,			layer_norm_eps=1e-05			,			num_attention_heads=4			,			num_hidden_layers=5			,			pad_token_id=1			,			vocab_size=1_0_0_0			,			)
      return CLIPTextModel(lowerCAmelCase_     )


   def  __magic_name__				(					self     :							int     ):

      """simple docstring"""
      _A:  List[Any]					=       self.dummy_uncond_unet
      _A:  Optional[Any]					=       DDIMScheduler()
      _A:  Tuple					=       self.dummy_vq_model

      _A:  Optional[Any]					=       LDMPipeline(unet=lowerCAmelCase_			,			vqvae=lowerCAmelCase_			,			scheduler=lowerCAmelCase_     )
      ldm.to(lowerCAmelCase_     )
      ldm.set_progress_bar_config(disable=lowerCAmelCase_     )

      _A:  Dict					=       torch.manual_seed(0     )
      _A:  str					=       ldm(generator=lowerCAmelCase_			,			num_inference_steps=2			,			output_type='''numpy'''     ).images

      _A:  int					=       torch.manual_seed(0     )
      _A:  List[Any]					=       ldm(generator=lowerCAmelCase_			,			num_inference_steps=2			,			output_type='''numpy'''			,			return_dict=lowerCAmelCase_     )[0]

      _A:  List[str]					=       image[0, -3:, -3:, -1]
      _A:  Union[str, Any]					=       image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 6_4, 6_4, 3)
      _A:  Optional[Any]					=       np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]     )
      _A:  Dict					=       1e-2 if torch_device != '''mps''' else 3e-2

      assert np.abs(image_slice.flatten() - expected_slice     ).max() < tolerance
      assert np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < tolerance






@slow
@require_torch
class UpperCAmelCase   (						unittest.TestCase   ):





   '''simple docstring'''


   def  __magic_name__				(					self     :							List[str]     ):

      """simple docstring"""
      _A:  List[Any]					=       LDMPipeline.from_pretrained('''CompVis/ldm-celebahq-256'''     )
      ldm.to(lowerCAmelCase_     )
      ldm.set_progress_bar_config(disable=lowerCAmelCase_     )

      _A:  List[Any]					=       torch.manual_seed(0     )
      _A:  Tuple					=       ldm(generator=lowerCAmelCase_			,			num_inference_steps=5			,			output_type='''numpy'''     ).images

      _A:  Optional[int]					=       image[0, -3:, -3:, -1]

      assert image.shape == (1, 2_5_6, 2_5_6, 3)
      _A:  Any					=       np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447]     )
      _A:  int					=       1e-2 if torch_device != '''mps''' else 3e-2

      assert np.abs(image_slice.flatten() - expected_slice     ).max() < tolerance





from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate






@dataclass(frozen=SCREAMING_SNAKE_CASE__   )
class UpperCAmelCase   (						SCREAMING_SNAKE_CASE__   ):





   '''simple docstring'''
   # `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
   __UpperCamelCase		:    str 				=    field(default='''question-answering-extractive'''							,							metadata={'''include_in_asdict_even_if_is_default''': True}   )
   __UpperCamelCase		:    ClassVar[Features] 				=    Features({'''question''': Value('''string'''   ), '''context''': Value('''string'''   )}   )
   __UpperCamelCase		:    ClassVar[Features] 				=    Features(
       {
           '''answers''': Sequence(
               {
                   '''text''': Value('''string'''   ),
                   '''answer_start''': Value('''int32'''   ),
               }   )
       }   )
   __UpperCamelCase		:    str 				=    "question"
   __UpperCamelCase		:    str 				=    "context"
   __UpperCamelCase		:    str 				=    "answers"


   @property
   def  __magic_name__				(					self     :							List[str]     ):

      """simple docstring"""
      return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}



