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


__lowerCAmelCase							:  Dict 				=		logging.get_logger(__name__)  # pylint: disable=invalid-name


__lowerCAmelCase							:  List[Any] 				=		"\n    Examples:\n        ```py\n        >>> import torch\n\n        >>> from diffusers import ConsistencyModelPipeline\n\n        >>> device = \"cuda\"\n        >>> # Load the cd_imagenet64_l2 checkpoint.\n        >>> model_id_or_path = \"openai/diffusers-cd_imagenet64_l2\"\n        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)\n        >>> pipe.to(device)\n\n        >>> # Onestep Sampling\n        >>> image = pipe(num_inference_steps=1).images[0]\n        >>> image.save(\"cd_imagenet64_l2_onestep_sample.png\")\n\n        >>> # Onestep sampling, class-conditional image generation\n        >>> # ImageNet-64 class label 145 corresponds to king penguins\n        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]\n        >>> image.save(\"cd_imagenet64_l2_onestep_sample_penguin.png\")\n\n        >>> # Multistep sampling, class-conditional image generation\n        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:\n        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77\n        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]\n        >>> image.save(\"cd_imagenet64_l2_multistep_sample_penguin.png\")\n        ```\n"
class SCREAMING_SNAKE_CASE       (      lowerCAmelCase					):






	'''simple docstring'''







	def __init__(  self :str       ,    __magic_name__ :UNetaDModel       ,    __magic_name__ :CMStochasticIterativeScheduler			)			->   None:

			'''simple docstring'''






			super().__init__()

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

			a__   		=     None


	def    _UpperCamelCase							(  self :List[Any]       ,    __magic_name__ :Tuple=0			)			->   Tuple:

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

			a__   		=     torch.device(F"cuda:{gpu_id}"			)

			if self.device.type != "cpu":
					self.to('''cpu'''       ,    silence_dtype_warnings=__magic_name__			)
					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(__magic_name__       ,    __magic_name__			)

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


	def    _UpperCamelCase							(  self :int       ,    __magic_name__ :str=0			)			->   Union[str, Any]:

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

			a__   		=     torch.device(F"cuda:{gpu_id}"			)

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

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

			if self.safety_checker is not None:
					a__		,	a__   		=     cpu_offload_with_hook(self.safety_checker       ,    __magic_name__       ,    prev_module_hook=__magic_name__			)

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


	@property
	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
	def    _UpperCamelCase							(  self :Dict			)			->   Optional[int]:

			'''simple docstring'''






			if not hasattr(self.unet       ,    '''_hf_hook'''			):
					return self.device
			for module in self.unet.modules():
					if (
					    hasattr(__magic_name__       ,    '''_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 :Optional[Any]       ,    __magic_name__ :str       ,    __magic_name__ :List[Any]       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[int]       ,    __magic_name__ :Union[str, Any]       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[Any]       ,    __magic_name__ :str=None			)			->   Optional[Any]:

			'''simple docstring'''






			a__   		=     (batch_size, num_channels, height, width)
			if isinstance(__magic_name__       ,    __magic_name__			) and len(__magic_name__			) != batch_size:
					raise ValueError(
					    F"You have passed a list of generators of length {len(__magic_name__			)}, 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:
					a__   		=     randn_tensor(__magic_name__       ,    generator=__magic_name__       ,    device=__magic_name__       ,    dtype=__magic_name__			)
			else:
					a__   		=     latents.to(device=__magic_name__       ,    dtype=__magic_name__			)

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


	def    _UpperCamelCase							(  self :Optional[int]       ,    __magic_name__ :torch.FloatTensor       ,    __magic_name__ :str = "pil"			)			->   List[Any]:

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

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

			# Output_type must be 'pil'
			a__   		=     self.numpy_to_pil(__magic_name__			)
			return sample


	def    _UpperCamelCase							(  self :Tuple       ,    __magic_name__ :str       ,    __magic_name__ :int       ,    __magic_name__ :Union[str, Any]=None			)			->   Tuple:

			'''simple docstring'''






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


	def    _UpperCamelCase							(  self :Union[str, Any]       ,    __magic_name__ :Dict       ,    __magic_name__ :Dict       ,    __magic_name__ :int       ,    __magic_name__ :int       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[int]			)			->   Any:

			'''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:
					a__   		=     (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(__magic_name__       ,    __magic_name__			) or callback_steps <= 0)
			):
					raise ValueError(
					    F"`callback_steps` has to be a positive integer but is {callback_steps} of type"
					    F" {type(__magic_name__			)}."			)






	@torch.no_grad()
	@replace_example_docstring(__magic_name__			)
	def __call__(  self :Dict       ,    __magic_name__ :int = 1       ,    __magic_name__ :Optional[Union[torch.Tensor, List[int], int]] = None       ,    __magic_name__ :int = 1       ,    __magic_name__ :List[int] = None       ,    __magic_name__ :Optional[Union[torch.Generator, List[torch.Generator]]] = None       ,    __magic_name__ :Optional[torch.FloatTensor] = None       ,    __magic_name__ :Optional[str] = "pil"       ,    __magic_name__ :bool = True       ,    __magic_name__ :Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,    __magic_name__ :int = 1       ,    )			->   Dict:

			'''simple docstring'''






			a__   		=     self.unet.config.sample_size
			a__   		=     self._execution_device

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

			# 2. Prepare image latents
			# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
			a__   		=     self.prepare_latents(
			    batch_size=__magic_name__       ,    num_channels=self.unet.config.in_channels       ,    height=__magic_name__       ,    width=__magic_name__       ,    dtype=self.unet.dtype       ,    device=__magic_name__       ,    generator=__magic_name__       ,    latents=__magic_name__       ,    )

			# 3. Handle class_labels for class-conditional models
			a__   		=     self.prepare_class_labels(__magic_name__       ,    __magic_name__       ,    class_labels=__magic_name__			)

			# 4. Prepare timesteps
			if timesteps is not None:
					self.scheduler.set_timesteps(timesteps=__magic_name__       ,    device=__magic_name__			)
					a__   		=     self.scheduler.timesteps
					a__   		=     len(__magic_name__			)
			else:
					self.scheduler.set_timesteps(__magic_name__			)
					a__   		=     self.scheduler.timesteps

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

							a__   		=     self.scheduler.step(__magic_name__       ,    __magic_name__       ,    __magic_name__       ,    generator=__magic_name__			)[0]

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

					# 6. Post-process image sample
			a__   		=     self.postprocess_image(__magic_name__       ,    output_type=__magic_name__			)

			# 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=__magic_name__			)










import subprocess
from typing import Union

import numpy as np
import requests

from ..utils import add_end_docstrings, is_torch_available, is_torchaudio_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING

_lowerCAmelCase    : List[str]		= logging.get_logger(__name__)



def     lowerCAmelCase		(		_lowerCAmelCase				: bytes    ,				_lowerCAmelCase				: int						):




 """simple docstring"""







 UpperCAmelCase__							=    F'''{sampling_rate}'''
 UpperCAmelCase__							=    "1"
 UpperCAmelCase__							=    "f32le"
 UpperCAmelCase__							=    [
     "ffmpeg",
     "-i",
     "pipe:0",
     "-ac",
     ac,
     "-ar",
     ar,
     "-f",
     format_for_conversion,
     "-hide_banner",
     "-loglevel",
     "quiet",
     "pipe:1",
 ]

 try:
  UpperCAmelCase__							=    subprocess.Popen(_lowerCAmelCase    ,				stdin=subprocess.PIPE    ,				stdout=subprocess.PIPE						)
 except FileNotFoundError:
  raise ValueError("ffmpeg was not found but is required to load audio files from filename"						)
 UpperCAmelCase__							=    ffmpeg_process.communicate(_lowerCAmelCase						)
 UpperCAmelCase__							=    output_stream[0]

 UpperCAmelCase__							=    np.frombuffer(_lowerCAmelCase    ,				np.floataa						)
 if audio.shape[0] == 0:
  raise ValueError("Malformed soundfile"						)
 return audio


@add_end_docstrings(lowerCAmelCase		)
class       _UpperCamelCase   (					lowerCAmelCase		):
      def __init__(      self :Any			,   *lowerCamelCase :Any			,   **lowerCamelCase :Optional[Any]   )  ->      Optional[int]:
       # Default, might be overriden by the model.config.
       UpperCAmelCase__							=    5
       super().__init__(*lowerCamelCase			,   **lowerCamelCase   )

       if self.framework != "pt":
        raise ValueError(f'''The {self.__class__} is only available in PyTorch.'''   )

       self.check_model_type(lowerCamelCase   )
      def __call__(      self :Optional[Any]			,   lowerCamelCase :Union[np.ndarray, bytes, str]			,   **lowerCamelCase :List[Any]			,   )  ->      Tuple:
       return super().__call__(lowerCamelCase			,   **lowerCamelCase   )
      def 						UpperCAmelCase_    (      self :str			,   lowerCamelCase :Dict=None			,   **lowerCamelCase :str   )  ->      int:
       # No parameters on this pipeline right now
       UpperCAmelCase__							=    {}
       if top_k is not None:
        if top_k > self.model.config.num_labels:
         UpperCAmelCase__							=    self.model.config.num_labels
        UpperCAmelCase__							=    top_k
       return {}, {}, postprocess_params
      def 						UpperCAmelCase_    (      self :Optional[Any]			,   lowerCamelCase :Dict   )  ->      Optional[int]:
       if isinstance(lowerCamelCase			,   lowerCamelCase   ):
        if inputs.startswith("http://"   ) or inputs.startswith("https://"   ):
         # We need to actually check for a real protocol, otherwise it's impossible to use a local file
         # like http_huggingface_co.png
         UpperCAmelCase__							=    requests.get(lowerCamelCase   ).content
        else:
         with open(lowerCamelCase			,   "rb"   ) as f:
          UpperCAmelCase__							=    f.read()

       if isinstance(lowerCamelCase			,   lowerCamelCase   ):
        UpperCAmelCase__							=    ffmpeg_read(lowerCamelCase			,   self.feature_extractor.sampling_rate   )

       if isinstance(lowerCamelCase			,   lowerCamelCase   ):
        # Accepting `"array"` which is the key defined in `datasets` for
        # better integration
        if not ("sampling_rate" in inputs and ("raw" in inputs or "array" in inputs)):
         raise ValueError(
             "When passing a dictionary to AudioClassificationPipeline, the dict needs to contain a "
             "\"raw\" key containing the numpy array representing the audio and a \"sampling_rate\" key, "
             "containing the sampling_rate associated with that array"   )

        UpperCAmelCase__							=    inputs.pop("raw"			,   lowerCamelCase   )
        if _inputs is None:
         # Remove path which will not be used from `datasets`.
         inputs.pop("path"			,   lowerCamelCase   )
         UpperCAmelCase__							=    inputs.pop("array"			,   lowerCamelCase   )
        UpperCAmelCase__							=    inputs.pop("sampling_rate"   )
        UpperCAmelCase__							=    _inputs
        if in_sampling_rate != self.feature_extractor.sampling_rate:
         import torch

         if is_torchaudio_available():
          from torchaudio import functional as F
         else:
          raise ImportError(
              "torchaudio is required to resample audio samples in AudioClassificationPipeline. "
              "The torchaudio package can be installed through: `pip install torchaudio`."   )

         UpperCAmelCase__							=    F.resample(
             torch.from_numpy(lowerCamelCase   )			,   lowerCamelCase			,   self.feature_extractor.sampling_rate   ).numpy()

       if not isinstance(lowerCamelCase			,   np.ndarray   ):
        raise ValueError("We expect a numpy ndarray as input"   )
       if len(inputs.shape   ) != 1:
        raise ValueError("We expect a single channel audio input for AudioClassificationPipeline"   )

       UpperCAmelCase__							=    self.feature_extractor(
           lowerCamelCase			,   sampling_rate=self.feature_extractor.sampling_rate			,   return_tensors="pt"   )
       return processed
      def 						UpperCAmelCase_    (      self :Tuple			,   lowerCamelCase :Union[str, Any]   )  ->      List[Any]:
       UpperCAmelCase__							=    self.model(**lowerCamelCase   )
       return model_outputs







      def 						UpperCAmelCase_    (      self :List[str]			,   lowerCamelCase :Optional[Any]			,   lowerCamelCase :List[Any]=5   )  ->      Tuple:
       UpperCAmelCase__							=    model_outputs.logits[0].softmax(-1   )
       UpperCAmelCase__			,			UpperCAmelCase__							=    probs.topk(lowerCamelCase   )

       UpperCAmelCase__							=    scores.tolist()
       UpperCAmelCase__							=    ids.tolist()

       UpperCAmelCase__							=    [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase			,   lowerCamelCase   )]

       return labels





