






"""simple docstring"""



import json
import os
import random
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
						from PIL import Image

						from transformers import FlavaImageProcessor, FlavaProcessor
						from transformers.models.flava.image_processing_flava import (
						    FLAVA_CODEBOOK_MEAN,
						    FLAVA_CODEBOOK_STD,
						    FLAVA_IMAGE_MEAN,
						    FLAVA_IMAGE_STD,
						)





@require_vision
class  _UpperCAmelCase	(			unittest.TestCase							):




					def   A  (    self					:						Optional[int]       )  ->  List[str]:
							lowercase_			:			Any								=       tempfile.mkdtemp()

							# fmt: off
							lowercase_			:			Dict								=       ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
							# fmt: on
							lowercase_			:			Any								=       os.path.join(self.tmpdirname   ,						VOCAB_FILES_NAMES['''vocab_file''']       )

							with open(self.vocab_file   ,						'''w'''   ,						encoding='''utf-8'''       ) as fp:
									fp.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )

							lowercase_			:			Union[str, Any]								=       {
							    '''image_mean''': FLAVA_IMAGE_MEAN,
							    '''image_std''': FLAVA_IMAGE_STD,
							    '''do_normalize''': True,
							    '''do_resize''': True,
							    '''size''': 2_24,
							    '''do_center_crop''': True,
							    '''crop_size''': 2_24,
							    '''input_size_patches''': 14,
							    '''total_mask_patches''': 75,
							    '''mask_group_max_patches''': None,
							    '''mask_group_min_patches''': 16,
							    '''mask_group_min_aspect_ratio''': 0.3,
							    '''mask_group_max_aspect_ratio''': None,
							    '''codebook_do_resize''': True,
							    '''codebook_size''': 1_12,
							    '''codebook_do_center_crop''': True,
							    '''codebook_crop_size''': 1_12,
							    '''codebook_do_map_pixels''': True,
							    '''codebook_do_normalize''': True,
							    '''codebook_image_mean''': FLAVA_CODEBOOK_MEAN,
							    '''codebook_image_std''': FLAVA_CODEBOOK_STD,
							}

							lowercase_			:			Any								=       os.path.join(self.tmpdirname   ,						A       )
							with open(self.image_processor_file   ,						'''w'''   ,						encoding='''utf-8'''       ) as fp:
									json.dump(A   ,						A       )




					def   A  (    self					:						Any   ,						**A					:						List[str]       )  ->  Optional[int]:
							return BertTokenizer.from_pretrained(self.tmpdirname   ,						**A       )




					def   A  (    self					:						int   ,						**A					:						Optional[Any]       )  ->  Tuple:
							return BertTokenizerFast.from_pretrained(self.tmpdirname   ,						**A       )




					def   A  (    self					:						Tuple   ,						**A					:						List[Any]       )  ->  Tuple:
							return FlavaImageProcessor.from_pretrained(self.tmpdirname   ,						**A       )




					def   A  (    self					:						int       )  ->  int:
							shutil.rmtree(self.tmpdirname       )




					def   A  (    self					:						int       )  ->  int:
							lowercase_			:			int								=       [np.random.randint(2_55   ,						size=(3, 30, 4_00)   ,						dtype=np.uinta       )]

							lowercase_			:			Tuple								=       [Image.fromarray(np.moveaxis(A   ,						0   ,						-1       )       ) for x in image_inputs]

							return image_inputs




					def   A  (    self					:						str       )  ->  List[str]:
							lowercase_			:			List[str]								=       self.get_tokenizer()
							lowercase_			:			Optional[Any]								=       self.get_rust_tokenizer()
							lowercase_			:			Optional[Any]								=       self.get_image_processor()

							lowercase_			:			Union[str, Any]								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )
							processor_slow.save_pretrained(self.tmpdirname       )
							lowercase_			:			Tuple								=       FlavaProcessor.from_pretrained(self.tmpdirname   ,						use_fast=A       )

							lowercase_			:			str								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )
							processor_fast.save_pretrained(self.tmpdirname       )
							lowercase_			:			Optional[Any]								=       FlavaProcessor.from_pretrained(self.tmpdirname       )

							self.assertEqual(processor_slow.tokenizer.get_vocab()   ,						tokenizer_slow.get_vocab()       )
							self.assertEqual(processor_fast.tokenizer.get_vocab()   ,						tokenizer_fast.get_vocab()       )
							self.assertEqual(tokenizer_slow.get_vocab()   ,						tokenizer_fast.get_vocab()       )
							self.assertIsInstance(processor_slow.tokenizer   ,						A       )
							self.assertIsInstance(processor_fast.tokenizer   ,						A       )

							self.assertEqual(processor_slow.image_processor.to_json_string()   ,						image_processor.to_json_string()       )
							self.assertEqual(processor_fast.image_processor.to_json_string()   ,						image_processor.to_json_string()       )
							self.assertIsInstance(processor_slow.image_processor   ,						A       )
							self.assertIsInstance(processor_fast.image_processor   ,						A       )




					def   A  (    self					:						List[str]       )  ->  Any:
							lowercase_			:			int								=       FlavaProcessor(tokenizer=self.get_tokenizer()   ,						image_processor=self.get_image_processor()       )
							processor.save_pretrained(self.tmpdirname       )

							lowercase_			:			Tuple								=       self.get_tokenizer(bos_token='''(BOS)'''   ,						eos_token='''(EOS)'''       )
							lowercase_			:			Optional[Any]								=       self.get_image_processor(do_normalize=A   ,						padding_value=1.0       )

							lowercase_			:			Optional[Any]								=       FlavaProcessor.from_pretrained(
							    self.tmpdirname   ,						bos_token='''(BOS)'''   ,						eos_token='''(EOS)'''   ,						do_normalize=A   ,						padding_value=1.0       )

							self.assertEqual(processor.tokenizer.get_vocab()   ,						tokenizer_add_kwargs.get_vocab()       )
							self.assertIsInstance(processor.tokenizer   ,						A       )

							self.assertEqual(processor.image_processor.to_json_string()   ,						image_processor_add_kwargs.to_json_string()       )
							self.assertIsInstance(processor.image_processor   ,						A       )




					def   A  (    self					:						Optional[int]       )  ->  Union[str, Any]:
							lowercase_			:			Union[str, Any]								=       self.get_image_processor()
							lowercase_			:			str								=       self.get_tokenizer()

							lowercase_			:			Dict								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )

							lowercase_			:			Tuple								=       self.prepare_image_inputs()

							lowercase_			:			Optional[Any]								=       image_processor(A   ,						return_tensors='''np'''       )
							lowercase_			:			Union[str, Any]								=       processor(images=A   ,						return_tensors='''np'''       )

							for key in input_feat_extract.keys():
									self.assertAlmostEqual(input_feat_extract[key].sum()   ,						input_processor[key].sum()   ,						delta=1e-2       )

							# With rest of the args
							random.seed(12_34       )
							lowercase_			:			str								=       image_processor(
							    A   ,						return_image_mask=A   ,						return_codebook_pixels=A   ,						return_tensors='''np'''       )
							random.seed(12_34       )
							lowercase_			:			Dict								=       processor(
							    images=A   ,						return_image_mask=A   ,						return_codebook_pixels=A   ,						return_tensors='''np'''       )

							for key in input_feat_extract.keys():
									self.assertAlmostEqual(input_feat_extract[key].sum()   ,						input_processor[key].sum()   ,						delta=1e-2       )




					def   A  (    self					:						Tuple       )  ->  Any:
							lowercase_			:			Any								=       self.get_image_processor()
							lowercase_			:			Dict								=       self.get_tokenizer()

							lowercase_			:			List[Any]								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )

							lowercase_			:			Union[str, Any]								=       '''lower newer'''

							lowercase_			:			Any								=       processor(text=A       )

							lowercase_			:			Tuple								=       tokenizer(A       )

							for key in encoded_tok.keys():
									self.assertListEqual(encoded_tok[key]   ,						encoded_processor[key]       )




					def   A  (    self					:						Tuple       )  ->  Optional[int]:
							lowercase_			:			List[Any]								=       self.get_image_processor()
							lowercase_			:			Dict								=       self.get_tokenizer()

							lowercase_			:			Tuple								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )

							lowercase_			:			Optional[Any]								=       '''lower newer'''
							lowercase_			:			str								=       self.prepare_image_inputs()

							lowercase_			:			List[Any]								=       processor(text=A   ,						images=A       )

							self.assertListEqual(list(inputs.keys()       )   ,						['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']       )

							# add extra args
							lowercase_			:			Dict								=       processor(text=A   ,						images=A   ,						return_codebook_pixels=A   ,						return_image_mask=A       )

							self.assertListEqual(
							    list(inputs.keys()       )   ,						[
							        '''input_ids''',
							        '''token_type_ids''',
							        '''attention_mask''',
							        '''pixel_values''',
							        '''codebook_pixel_values''',
							        '''bool_masked_pos''',
							    ]   ,						)

							# test if it raises when no input is passed
							with pytest.raises(A       ):
									processor()




					def   A  (    self					:						str       )  ->  Tuple:
							lowercase_			:			Union[str, Any]								=       self.get_image_processor()
							lowercase_			:			Any								=       self.get_tokenizer()

							lowercase_			:			Union[str, Any]								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )

							lowercase_			:			Any								=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							lowercase_			:			str								=       processor.batch_decode(A       )
							lowercase_			:			Union[str, Any]								=       tokenizer.batch_decode(A       )

							self.assertListEqual(A   ,						A       )






					def   A  (    self					:						List[str]       )  ->  Optional[Any]:
							lowercase_			:			Any								=       self.get_image_processor()
							lowercase_			:			Optional[int]								=       self.get_tokenizer()

							lowercase_			:			Optional[Any]								=       FlavaProcessor(tokenizer=A   ,						image_processor=A       )

							lowercase_			:			Tuple								=       '''lower newer'''
							lowercase_			:			List[str]								=       self.prepare_image_inputs()

							lowercase_			:			Optional[Any]								=       processor(text=A   ,						images=A       )

							self.assertListEqual(list(inputs.keys()       )   ,						processor.model_input_names       )








"""simple docstring"""



from typing import Callable, List, Optional, Union

import torch

from ...models import UNetaDModel
from ...schedulers import CMStochasticIterativeScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


__A		:	Union[str, Any]      =		logging.get_logger(__name__)  # pylint: disable=invalid-name


__A		:	str      =		'''
    Examples:
        ```py
        >>> import torch

        >>> from diffusers import ConsistencyModelPipeline

        >>> device = "cuda"
        >>> # Load the cd_imagenet64_l2 checkpoint.
        >>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2"
        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
        >>> pipe.to(device)

        >>> # Onestep Sampling
        >>> image = pipe(num_inference_steps=1).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample.png")

        >>> # Onestep sampling, class-conditional image generation
        >>> # ImageNet-64 class label 145 corresponds to king penguins
        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png")

        >>> # Multistep sampling, class-conditional image generation
        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:
        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77
        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png")
        ```
'''





class  _UpperCAmelCase	(			_A							):




					def __init__(    self					:						Union[str, Any]   ,						A					:						UNetaDModel   ,						A					:						CMStochasticIterativeScheduler       )  ->  None:
							super().__init__()

							self.register_modules(
							    unet=A   ,						scheduler=A   ,						)

							lowercase_			:			Any								=       None




					def   A  (    self					:						Tuple   ,						A					:						Union[str, Any]=0       )  ->  Optional[Any]:
							if is_accelerate_available() and is_accelerate_version('''>='''   ,						'''0.14.0'''       ):
									from accelerate import cpu_offload
							else:
									raise ImportError('''`enable_sequential_cpu_offload` requires `accelerate v0.14.0` or higher'''       )

							lowercase_			:			Any								=       torch.device(F'''cuda:{gpu_id}'''       )

							if self.device.type != "cpu":
									self.to('''cpu'''   ,						silence_dtype_warnings=A       )
									torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

							for cpu_offloaded_model in [self.unet]:
									cpu_offload(A   ,						A       )

							if self.safety_checker is not None:
									cpu_offload(self.safety_checker   ,						execution_device=A   ,						offload_buffers=A       )




					def   A  (    self					:						List[Any]   ,						A					:						Optional[Any]=0       )  ->  List[Any]:
							if is_accelerate_available() and is_accelerate_version('''>='''   ,						'''0.17.0.dev0'''       ):
									from accelerate import cpu_offload_with_hook
							else:
									raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''       )

							lowercase_			:			List[str]								=       torch.device(F'''cuda:{gpu_id}'''       )

							if self.device.type != "cpu":
									self.to('''cpu'''   ,						silence_dtype_warnings=A       )
									torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

							lowercase_			:			Union[str, Any]								=       None
							for cpu_offloaded_model in [self.unet]:
									lowercase_	, lowercase_			:			Optional[int]								=       cpu_offload_with_hook(A   ,						A   ,						prev_module_hook=A       )

							if self.safety_checker is not None:
									lowercase_	, lowercase_			:			Any								=       cpu_offload_with_hook(self.safety_checker   ,						A   ,						prev_module_hook=A       )

							# We'll offload the last model manually.
							lowercase_			:			str								=       hook




					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def   A  (    self					:						Any       )  ->  List[str]:
							if not hasattr(self.unet   ,						'''_hf_hook'''       ):
									return self.device
							for module in self.unet.modules():
									if (
									    hasattr(A   ,						'''_hf_hook'''       )
									    and hasattr(module._hf_hook   ,						'''execution_device'''       )
									    and module._hf_hook.execution_device is not None
									):
											return torch.device(module._hf_hook.execution_device       )
							return self.device




					def   A  (    self					:						List[str]   ,						A					:						int   ,						A					:						Union[str, Any]   ,						A					:						List[str]   ,						A					:						str   ,						A					:						int   ,						A					:						List[Any]   ,						A					:						Optional[Any]   ,						A					:						Optional[Any]=None       )  ->  Tuple:
							lowercase_			:			List[Any]								=       (batch_size, num_channels, height, width)
							if isinstance(A   ,						A       ) and len(A       ) != batch_size:
									raise ValueError(
									    F'''You have passed a list of generators of length {len(A       )}, but requested an effective batch'''
									    F''' size of {batch_size}. Make sure the batch size matches the length of the generators.'''       )

							if latents is None:
									lowercase_			:			Dict								=       randn_tensor(A   ,						generator=A   ,						device=A   ,						dtype=A       )
							else:
									lowercase_			:			Tuple								=       latents.to(device=A   ,						dtype=A       )

							# scale the initial noise by the standard deviation required by the scheduler
							lowercase_			:			List[str]								=       latents * self.scheduler.init_noise_sigma
							return latents




					def   A  (    self					:						Tuple   ,						A					:						torch.FloatTensor   ,						A					:						str = "pil"       )  ->  Optional[int]:
							if output_type not in ["pt", "np", "pil"]:
									raise ValueError(
									    F'''output_type={output_type} is not supported. Make sure to choose one of [\'pt\', \'np\', or \'pil\']'''       )

							# Equivalent to diffusers.VaeImageProcessor.denormalize
							lowercase_			:			Dict								=       (sample / 2 + 0.5).clamp(0   ,						1       )
							if output_type == "pt":
									return sample

							# Equivalent to diffusers.VaeImageProcessor.pt_to_numpy
							lowercase_			:			List[str]								=       sample.cpu().permute(0   ,						2   ,						3   ,						1       ).numpy()
							if output_type == "np":
									return sample

							# Output_type must be 'pil'
							lowercase_			:			List[Any]								=       self.numpy_to_pil(A       )
							return sample




					def   A  (    self					:						Optional[int]   ,						A					:						Any   ,						A					:						Union[str, Any]   ,						A					:						Optional[int]=None       )  ->  List[Any]:
							if self.unet.config.num_class_embeds is not None:
									if isinstance(A   ,						A       ):
											lowercase_			:			Optional[int]								=       torch.tensor(A   ,						dtype=torch.int       )
									elif isinstance(A   ,						A       ):
											assert batch_size == 1, "Batch size must be 1 if classes is an int"
											lowercase_			:			int								=       torch.tensor([class_labels]   ,						dtype=torch.int       )
									elif class_labels is None:
											# Randomly generate batch_size class labels
											# TODO: should use generator here? int analogue of randn_tensor is not exposed in ...utils
											lowercase_			:			Any								=       torch.randint(0   ,						self.unet.config.num_class_embeds   ,						size=(batch_size,)       )
									lowercase_			:			List[str]								=       class_labels.to(A       )
							else:
									lowercase_			:			Union[str, Any]								=       None
							return class_labels




					def   A  (    self					:						Dict   ,						A					:						Union[str, Any]   ,						A					:						Any   ,						A					:						Optional[int]   ,						A					:						Union[str, Any]   ,						A					:						Any   ,						A					:						int       )  ->  Union[str, Any]:
							if num_inference_steps is None and timesteps is None:
									raise ValueError('''Exactly one of `num_inference_steps` or `timesteps` must be supplied.'''       )

							if num_inference_steps is not None and timesteps is not None:
									logger.warning(
									    F'''Both `num_inference_steps`: {num_inference_steps} and `timesteps`: {timesteps} are supplied;'''
									    ''' `timesteps` will be used over `num_inference_steps`.'''       )

							if latents is not None:
									lowercase_			:			List[Any]								=       (batch_size, 3, img_size, img_size)
									if latents.shape != expected_shape:
											raise ValueError(F'''The shape of latents is {latents.shape} but is expected to be {expected_shape}.'''       )

							if (callback_steps is None) or (
							    callback_steps is not None and (not isinstance(A   ,						A       ) or callback_steps <= 0)
							):
									raise ValueError(
									    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
									    F''' {type(A       )}.'''       )






					@torch.no_grad()
					@replace_example_docstring(A       )
					def __call__(    self					:						Optional[Any]   ,						A					:						int = 1   ,						A					:						Optional[Union[torch.Tensor, List[int], int]] = None   ,						A					:						int = 1   ,						A					:						List[int] = None   ,						A					:						Optional[Union[torch.Generator, List[torch.Generator]]] = None   ,						A					:						Optional[torch.FloatTensor] = None   ,						A					:						Optional[str] = "pil"   ,						A					:						bool = True   ,						A					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None   ,						A					:						int = 1   ,						)  ->  Tuple:
							lowercase_			:			Dict								=       self.unet.config.sample_size
							lowercase_			:			Union[str, Any]								=       self._execution_device

							# 1. Check inputs
							self.check_inputs(A   ,						A   ,						A   ,						A   ,						A   ,						A       )

							# 2. Prepare image latents
							# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
							lowercase_			:			Optional[int]								=       self.prepare_latents(
							    batch_size=A   ,						num_channels=self.unet.config.in_channels   ,						height=A   ,						width=A   ,						dtype=self.unet.dtype   ,						device=A   ,						generator=A   ,						latents=A   ,						)

							# 3. Handle class_labels for class-conditional models
							lowercase_			:			List[str]								=       self.prepare_class_labels(A   ,						A   ,						class_labels=A       )

							# 4. Prepare timesteps
							if timesteps is not None:
									self.scheduler.set_timesteps(timesteps=A   ,						device=A       )
									lowercase_			:			Optional[int]								=       self.scheduler.timesteps
									lowercase_			:			List[Any]								=       len(A       )
							else:
									self.scheduler.set_timesteps(A       )
									lowercase_			:			Any								=       self.scheduler.timesteps

							# 5. Denoising loop
							# Multistep sampling: implements Algorithm 1 in the paper
							with self.progress_bar(total=A       ) as progress_bar:
									for i, t in enumerate(A       ):
											lowercase_			:			List[str]								=       self.scheduler.scale_model_input(A   ,						A       )
											lowercase_			:			Optional[Any]								=       self.unet(A   ,						A   ,						class_labels=A   ,						return_dict=A       )[0]

											lowercase_			:			Tuple								=       self.scheduler.step(A   ,						A   ,						A   ,						generator=A       )[0]

											# call the callback, if provided
											progress_bar.update()
											if callback is not None and i % callback_steps == 0:
													callback(A   ,						A   ,						A       )

        # 6. Post-process image sample
							lowercase_			:			Union[str, Any]								=       self.postprocess_image(A   ,						output_type=A       )

							# Offload last model to CPU
							if hasattr(self   ,						'''final_offload_hook'''       ) and self.final_offload_hook is not None:
									self.final_offload_hook.offload()

							if not return_dict:
									return (image,)

							return ImagePipelineOutput(images=A       )



