





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


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


lowercase     :			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 			__A(    __UpperCAmelCase			):

     def __init__(   self,							A,							A   ):





            """simple docstring"""

            super().__init__()

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

            _UpperCamelCase														=    None

     def 						_UpperCamelCase  (   self,							A=0   ):





            """simple docstring"""

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

            _UpperCamelCase														=    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 						_UpperCamelCase  (   self,							A=0   ):





            """simple docstring"""

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

            _UpperCamelCase														=    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)

            _UpperCamelCase														=    None
            for cpu_offloaded_model in [self.unet]:
                   _UpperCamelCase							,		_UpperCamelCase														=    cpu_offload_with_hook(A,							A,							prev_module_hook=A   )

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

            # We'll offload the last model manually.
            _UpperCamelCase														=    hook

     @property
     # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            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 						_UpperCamelCase  (   self,							A,							A,							A,							A,							A,							A,							A,							A=None   ):





            """simple docstring"""

            _UpperCamelCase														=    (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:
                   _UpperCamelCase														=    randn_tensor(A,							generator=A,							device=A,							dtype=A   )
            else:
                   _UpperCamelCase														=    latents.to(device=A,							dtype=A   )

            # scale the initial noise by the standard deviation required by the scheduler
            _UpperCamelCase														=    latents * self.scheduler.init_noise_sigma
            return latents

     def 						_UpperCamelCase  (   self,							A,							A = "pil"   ):





            """simple docstring"""

            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
            _UpperCamelCase														=    (sample / 2 + 0.5).clamp(0,							1   )
            if output_type == "pt":
                   return sample

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

            # Output_type must be 'pil'
            _UpperCamelCase														=    self.numpy_to_pil(A   )
            return sample

     def 						_UpperCamelCase  (   self,							A,							A,							A=None   ):





            """simple docstring"""

            if self.unet.config.num_class_embeds is not None:
                   if isinstance(A,							A   ):
                          _UpperCamelCase														=    torch.tensor(A,							dtype=torch.int   )
                   elif isinstance(A,							A   ):
                          assert batch_size == 1, "Batch size must be 1 if classes is an int"
                          _UpperCamelCase														=    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
                          _UpperCamelCase														=    torch.randint(0,							self.unet.config.num_class_embeds,							size=(batch_size,)   )
                   _UpperCamelCase														=    class_labels.to(A   )
            else:
                   _UpperCamelCase														=    None
            return class_labels

     def 						_UpperCamelCase  (   self,							A,							A,							A,							A,							A,							A   ):





            """simple docstring"""

            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:
                   _UpperCamelCase														=    (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,							A = 1,							A = None,							A = 1,							A = None,							A = None,							A = None,							A = "pil",							A = True,							A = None,							A = 1,							):





            """simple docstring"""

            _UpperCamelCase														=    self.unet.config.sample_size
            _UpperCamelCase														=    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)
            _UpperCamelCase														=    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
            _UpperCamelCase														=    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   )
                   _UpperCamelCase														=    self.scheduler.timesteps
                   _UpperCamelCase														=    len(A   )
            else:
                   self.scheduler.set_timesteps(A   )
                   _UpperCamelCase														=    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   ):
                          _UpperCamelCase														=    self.scheduler.scale_model_input(A,							A   )
                          _UpperCamelCase														=    self.unet(A,							A,							class_labels=A,							return_dict=A   )[0]

                          _UpperCamelCase														=    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
            _UpperCamelCase														=    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   )













import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import AutoProcessor, BertTokenizer, CLIPImageProcessor, GitProcessor, PreTrainedTokenizerFast

@require_vision
class 			__A(    unittest.TestCase			):

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    tempfile.mkdtemp()

            _UpperCamelCase														=    CLIPImageProcessor()
            _UpperCamelCase														=    BertTokenizer.from_pretrained(
                '''hf-internal-testing/tiny-random-BertModel''',							model_input_names=['''input_ids''', '''attention_mask''']   )

            _UpperCamelCase														=    GitProcessor(A,							A   )

            processor.save_pretrained(self.tmpdirname   )

     def 						_UpperCamelCase  (   self,							**A   ):





            """simple docstring"""

            return AutoProcessor.from_pretrained(self.tmpdirname,							**A   ).tokenizer

     def 						_UpperCamelCase  (   self,							**A   ):





            """simple docstring"""

            return AutoProcessor.from_pretrained(self.tmpdirname,							**A   ).image_processor

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            shutil.rmtree(self.tmpdirname   )

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    [np.random.randint(255,							size=(3, 30, 400),							dtype=np.uinta   )]

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

            return image_inputs

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    GitProcessor(tokenizer=self.get_tokenizer(),							image_processor=self.get_image_processor()   )
            processor.save_pretrained(self.tmpdirname   )

            _UpperCamelCase														=    self.get_tokenizer(bos_token='''(BOS)''',							eos_token='''(EOS)'''   )
            _UpperCamelCase														=    self.get_image_processor(do_normalize=A,							padding_value=1.0   )

            _UpperCamelCase														=    GitProcessor.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 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.get_image_processor()
            _UpperCamelCase														=    self.get_tokenizer()

            _UpperCamelCase														=    GitProcessor(tokenizer=A,							image_processor=A   )

            _UpperCamelCase														=    self.prepare_image_inputs()

            _UpperCamelCase														=    image_processor(A,							return_tensors='''np'''   )
            _UpperCamelCase														=    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   )

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.get_image_processor()
            _UpperCamelCase														=    self.get_tokenizer()

            _UpperCamelCase														=    GitProcessor(tokenizer=A,							image_processor=A   )

            _UpperCamelCase														=    '''lower newer'''

            _UpperCamelCase														=    processor(text=A   )

            _UpperCamelCase														=    tokenizer(A,							return_token_type_ids=A   )

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

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.get_image_processor()
            _UpperCamelCase														=    self.get_tokenizer()

            _UpperCamelCase														=    GitProcessor(tokenizer=A,							image_processor=A   )

            _UpperCamelCase														=    '''lower newer'''
            _UpperCamelCase														=    self.prepare_image_inputs()

            _UpperCamelCase														=    processor(text=A,							images=A   )

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

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

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.get_image_processor()
            _UpperCamelCase														=    self.get_tokenizer()

            _UpperCamelCase														=    GitProcessor(tokenizer=A,							image_processor=A   )

            _UpperCamelCase														=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

            _UpperCamelCase														=    processor.batch_decode(A   )
            _UpperCamelCase														=    tokenizer.batch_decode(A   )

            self.assertListEqual(A,							A   )



     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.get_image_processor()
            _UpperCamelCase														=    self.get_tokenizer()

            _UpperCamelCase														=    GitProcessor(tokenizer=A,							image_processor=A   )

            _UpperCamelCase														=    '''lower newer'''
            _UpperCamelCase														=    self.prepare_image_inputs()

            _UpperCamelCase														=    processor(text=A,							images=A   )

            # For now the processor supports only ['input_ids', 'attention_mask', 'pixel_values']
            self.assertListEqual(list(inputs.keys()   ),							['''input_ids''', '''attention_mask''', '''pixel_values''']   )






