


import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases

def 			__UpperCamelCase    (    _A    :				Union[str, Any]					,   _A    :				Optional[int]				)    ->      int:




	"""simple docstring"""





	assert isinstance(_A					,   _A				)
	assert dataset.num_rows == 4
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_1", "col_2", "col_3"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('keep_in_memory'					,   [False, True]				)
def 			__UpperCamelCase    (    _A    :				Dict					,   _A    :				int					,   _A    :				Any				)    ->      str:




	"""simple docstring"""





	lowerCAmelCase					:    str      							= tmp_path / 'cache'
	lowerCAmelCase					:    str      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
		lowerCAmelCase					:    List[str]      							= JsonDatasetReader(_A					,   cache_dir=_A					,   keep_in_memory=_A				).read()
	_check_json_dataset(_A					,   _A				)

@pytest.mark.parametrize(
    'features'					,   [
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ]					,   )
def 			__UpperCamelCase    (    _A    :				int					,   _A    :				List[Any]					,   _A    :				Optional[Any]				)    ->      str:




	"""simple docstring"""





	lowerCAmelCase					:    int      							= tmp_path / 'cache'
	lowerCAmelCase					:    Tuple      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	lowerCAmelCase					:    Union[str, Any]      							= features.copy() if features else default_expected_features
	lowerCAmelCase					:    Tuple      							= (
	    Features({feature: Value(_A				) for feature, dtype in features.items()}				) if features is not None else None
	)
	lowerCAmelCase					:    List[Any]      							= JsonDatasetReader(_A					,   features=_A					,   cache_dir=_A				).read()
	_check_json_dataset(_A					,   _A				)

@pytest.mark.parametrize(
    'features'					,   [
        None,
        {'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'},
    ]					,   )
def 			__UpperCamelCase    (    _A    :				Any					,   _A    :				Dict					,   _A    :				Optional[Any]				)    ->      Dict:




	"""simple docstring"""





	lowerCAmelCase					:    str      							= tmp_path / 'cache'
	lowerCAmelCase					:    Optional[int]      							= {'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'}
	lowerCAmelCase					:    Any      							= features.copy() if features else default_expected_features
	lowerCAmelCase					:    List[Any]      							= (
	    Features({feature: Value(_A				) for feature, dtype in features.items()}				) if features is not None else None
	)
	lowerCAmelCase					:    Optional[int]      							= JsonDatasetReader(_A					,   features=_A					,   cache_dir=_A				).read()
	assert isinstance(_A					,   _A				)
	assert dataset.num_rows == 2
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_3", "col_1", "col_2"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype

def 			__UpperCamelCase    (    _A    :				Dict					,   _A    :				Union[str, Any]				)    ->      Dict:




	"""simple docstring"""





	lowerCAmelCase					:    int      							= {'col_2': 'int64', 'col_3': 'float64', 'col_1': 'string'}
	lowerCAmelCase					:    Optional[int]      							= features.copy()
	lowerCAmelCase					:    int      							= (
	    Features({feature: Value(_A				) for feature, dtype in features.items()}				) if features is not None else None
	)
	lowerCAmelCase					:    Any      							= tmp_path / 'cache'
	lowerCAmelCase					:    Dict      							= JsonDatasetReader(_A					,   features=_A					,   cache_dir=_A				).read()
	assert isinstance(_A					,   _A				)
	assert dataset.num_rows == 2
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_2", "col_3", "col_1"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('split'					,   [None, NamedSplit('train'				), 'train', 'test']				)
def 			__UpperCamelCase    (    _A    :				Optional[int]					,   _A    :				int					,   _A    :				Union[str, Any]				)    ->      Optional[Any]:




	"""simple docstring"""





	lowerCAmelCase					:    Optional[Any]      							= tmp_path / 'cache'
	lowerCAmelCase					:    Dict      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	lowerCAmelCase					:    int      							= JsonDatasetReader(_A					,   cache_dir=_A					,   split=_A				).read()
	_check_json_dataset(_A					,   _A				)
	assert dataset.split == split if split else "train"

@pytest.mark.parametrize('path_type'					,   [str, list]				)
def 			__UpperCamelCase    (    _A    :				Any					,   _A    :				str					,   _A    :				Dict				)    ->      List[str]:




	"""simple docstring"""





	if issubclass(_A					,   _A				):
		lowerCAmelCase					:    Optional[int]      							= jsonl_path
	elif issubclass(_A					,   _A				):
		lowerCAmelCase					:    Optional[Any]      							= [jsonl_path]
	lowerCAmelCase					:    Any      							= tmp_path / 'cache'
	lowerCAmelCase					:    Union[str, Any]      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	lowerCAmelCase					:    Dict      							= JsonDatasetReader(_A					,   cache_dir=_A				).read()
	_check_json_dataset(_A					,   _A				)

def 			__UpperCamelCase    (    _A    :				int					,   _A    :				int					,   _A    :				Optional[int]=("train",)				)    ->      int:




	"""simple docstring"""





	assert isinstance(_A					,   _A				)
	for split in splits:
		lowerCAmelCase					:    str      							= dataset_dict[split]
		assert dataset.num_rows == 4
		assert dataset.num_columns == 3
		assert dataset.column_names == ["col_1", "col_2", "col_3"]
		for feature, expected_dtype in expected_features.items():
			assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('keep_in_memory'					,   [False, True]				)
def 			__UpperCamelCase    (    _A    :				Optional[Any]					,   _A    :				int					,   _A    :				List[str]				)    ->      List[Any]:




	"""simple docstring"""





	lowerCAmelCase					:    Optional[int]      							= tmp_path / 'cache'
	lowerCAmelCase					:    List[Any]      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
		lowerCAmelCase					:    Optional[Any]      							= JsonDatasetReader({'train': jsonl_path}					,   cache_dir=_A					,   keep_in_memory=_A				).read()
	_check_json_datasetdict(_A					,   _A				)

@pytest.mark.parametrize(
    'features'					,   [
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ]					,   )
def 			__UpperCamelCase    (    _A    :				Optional[Any]					,   _A    :				Any					,   _A    :				Any				)    ->      Tuple:




	"""simple docstring"""





	lowerCAmelCase					:    List[Any]      							= tmp_path / 'cache'
	lowerCAmelCase					:    Union[str, Any]      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	lowerCAmelCase					:    Dict      							= features.copy() if features else default_expected_features
	lowerCAmelCase					:    Dict      							= (
	    Features({feature: Value(_A				) for feature, dtype in features.items()}				) if features is not None else None
	)
	lowerCAmelCase					:    Dict      							= JsonDatasetReader({'train': jsonl_path}					,   features=_A					,   cache_dir=_A				).read()
	_check_json_datasetdict(_A					,   _A				)

@pytest.mark.parametrize('split'					,   [None, NamedSplit('train'				), 'train', 'test']				)
def 			__UpperCamelCase    (    _A    :				Any					,   _A    :				Optional[Any]					,   _A    :				Union[str, Any]				)    ->      str:




	"""simple docstring"""





	if split:
		lowerCAmelCase					:    Optional[Any]      							= {split: jsonl_path}
	else:
		lowerCAmelCase					:    Any      							= 'train'
		lowerCAmelCase					:    Tuple      							= {'train': jsonl_path, 'test': jsonl_path}
	lowerCAmelCase					:    str      							= tmp_path / 'cache'
	lowerCAmelCase					:    Optional[Any]      							= {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
	lowerCAmelCase					:    str      							= JsonDatasetReader(_A					,   cache_dir=_A				).read()
	_check_json_datasetdict(_A					,   _A					,   splits=list(path.keys()				)				)
	assert all(dataset[split].split == split for split in path.keys()				)

def 			__UpperCamelCase    (    _A    :				Union[str, Any]				)    ->      Optional[int]:




	"""simple docstring"""





	return json.load(_A				)

def 			__UpperCamelCase    (    _A    :				Optional[int]				)    ->      List[str]:




	"""simple docstring"""





	return [json.loads(_A				) for line in buffer]






class  lowerCAmelCase				:



	@pytest.mark.parametrize('lines, load_json_function' ,					[(True, load_json_lines), (False, load_json)]    )
	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		with io.BytesIO() as buffer:
			JsonDatasetWriter(snake_case__ ,					snake_case__ ,					lines=snake_case__    ).write()
			buffer.seek(0    )
			lowerCAmelCase					:    Optional[Any]      							= load_json_function(snake_case__    )
		assert isinstance(snake_case__ ,					snake_case__    )
		assert isinstance(exported_content[0] ,					snake_case__    )
		assert len(snake_case__    ) == 10



	@pytest.mark.parametrize(
	    'orient, container, keys, len_at' ,					[
	        ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
	        ('split', dict, {'columns', 'data'}, 'data'),
	        ('index', dict, set('0123456789'    ), None),
	        ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
	        ('values', list, None, None),
	        ('table', dict, {'schema', 'data'}, 'data'),
	    ] ,					)
	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		with io.BytesIO() as buffer:
			JsonDatasetWriter(snake_case__ ,					snake_case__ ,					lines=snake_case__ ,					orient=snake_case__    ).write()
			buffer.seek(0    )
			lowerCAmelCase					:    List[str]      							= load_json(snake_case__    )
		assert isinstance(snake_case__ ,					snake_case__    )
		if keys:
			if container is dict:
				assert exported_content.keys() == keys
			else:
				assert exported_content[0].keys() == keys
		else:
			assert not hasattr(snake_case__ ,					'keys'    ) and not hasattr(exported_content[0] ,					'keys'    )
		if len_at:
			assert len(exported_content[len_at]    ) == 10
		else:
			assert len(snake_case__    ) == 10



	@pytest.mark.parametrize('lines, load_json_function' ,					[(True, load_json_lines), (False, load_json)]    )
	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		with io.BytesIO() as buffer:
			JsonDatasetWriter(snake_case__ ,					snake_case__ ,					lines=snake_case__ ,					num_proc=2    ).write()
			buffer.seek(0    )
			lowerCAmelCase					:    Any      							= load_json_function(snake_case__    )
		assert isinstance(snake_case__ ,					snake_case__    )
		assert isinstance(exported_content[0] ,					snake_case__    )
		assert len(snake_case__    ) == 10



	@pytest.mark.parametrize(
	    'orient, container, keys, len_at' ,					[
	        ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
	        ('split', dict, {'columns', 'data'}, 'data'),
	        ('index', dict, set('0123456789'    ), None),
	        ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
	        ('values', list, None, None),
	        ('table', dict, {'schema', 'data'}, 'data'),
	    ] ,					)
	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		with io.BytesIO() as buffer:
			JsonDatasetWriter(snake_case__ ,					snake_case__ ,					lines=snake_case__ ,					orient=snake_case__ ,					num_proc=2    ).write()
			buffer.seek(0    )
			lowerCAmelCase					:    List[Any]      							= load_json(snake_case__    )
		assert isinstance(snake_case__ ,					snake_case__    )
		if keys:
			if container is dict:
				assert exported_content.keys() == keys
			else:
				assert exported_content[0].keys() == keys
		else:
			assert not hasattr(snake_case__ ,					'keys'    ) and not hasattr(exported_content[0] ,					'keys'    )
		if len_at:
			assert len(exported_content[len_at]    ) == 10
		else:
			assert len(snake_case__    ) == 10



	def 				lowercase     (					self ,					snake_case__    ):
		with pytest.raises(snake_case__    ):
			with io.BytesIO() as buffer:
				JsonDatasetWriter(snake_case__ ,					snake_case__ ,					num_proc=0    )



	@pytest.mark.parametrize('compression, extension' ,					[('gzip', 'gz'), ('bz2', 'bz2'), ('xz', 'xz')]    )
	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    int      							= tmp_path_factory.mktemp('data'    ) / f"test.json.{extension}"
		lowerCAmelCase					:    Optional[int]      							= str(shared_datadir / f"test_file.json.{extension}"    )
		JsonDatasetWriter(snake_case__ ,					snake_case__ ,					compression=snake_case__    ).write()

		with fsspec.open(snake_case__ ,					'rb' ,					compression='infer'    ) as f:
			lowerCAmelCase					:    Union[str, Any]      							= f.read()
		with fsspec.open(snake_case__ ,					'rb' ,					compression='infer'    ) as f:
			lowerCAmelCase					:    Optional[int]      							= f.read()
		assert exported_content == original_content




'''simple docstring'''




import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextModel,
    CLIPTokenizer,
    WhisperForConditionalGeneration,
    WhisperProcessor,
)

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import logging


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



class  lowerCAmelCase				(				a							):



	def __init__(					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					):
		super().__init__()

		if safety_checker is None:
			logger.warning(
			    f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
			    ' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered'
			    ' results in services or applications open to the public. Both the diffusers team and Hugging Face'
			    ' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling'
			    ' it only for use-cases that involve analyzing network behavior or auditing its results. For more'
			    ' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .'    )

		self.register_modules(
		    speech_model=snake_case__ ,					speech_processor=snake_case__ ,					vae=snake_case__ ,					text_encoder=snake_case__ ,					tokenizer=snake_case__ ,					unet=snake_case__ ,					scheduler=snake_case__ ,					feature_extractor=snake_case__ ,					)



	def 				lowercase     (					self ,					snake_case__ = "auto"    ):
		if slice_size == "auto":
			lowerCAmelCase					:    Union[str, Any]      							= self.unet.config.attention_head_dim // 2
		self.unet.set_attention_slice(snake_case__    )



	def 				lowercase     (					self    ):
		self.enable_attention_slicing(snake_case__    )



	@torch.no_grad()
	def __call__(					self ,					snake_case__ ,					snake_case__=1_6000 ,					snake_case__ = 512 ,					snake_case__ = 512 ,					snake_case__ = 50 ,					snake_case__ = 7.5 ,					snake_case__ = None ,					snake_case__ = 1 ,					snake_case__ = 0.0 ,					snake_case__ = None ,					snake_case__ = None ,					snake_case__ = "pil" ,					snake_case__ = True ,					snake_case__ = None ,					snake_case__ = 1 ,					**snake_case__ ,					):
		lowerCAmelCase					:    List[str]      							= self.speech_processor.feature_extractor(
		    snake_case__ ,					return_tensors='pt' ,					sampling_rate=snake_case__    ).input_features.to(self.device    )
		lowerCAmelCase					:    Optional[Any]      							= self.speech_model.generate(snake_case__ ,					max_length=48_0000    )

		lowerCAmelCase					:    str      							= self.speech_processor.tokenizer.batch_decode(snake_case__ ,					skip_special_tokens=snake_case__ ,					normalize=snake_case__    )[
		    0
		]

		if isinstance(snake_case__ ,					snake_case__    ):
			lowerCAmelCase					:    Optional[int]      							= 1
		elif isinstance(snake_case__ ,					snake_case__    ):
			lowerCAmelCase					:    Optional[int]      							= len(snake_case__    )
		else:
			raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(snake_case__    )}"    )

		if height % 8 != 0 or width % 8 != 0:
			raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}."    )

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

		# get prompt text embeddings
		lowerCAmelCase					:    str      							= self.tokenizer(
		    snake_case__ ,					padding='max_length' ,					max_length=self.tokenizer.model_max_length ,					return_tensors='pt' ,					)
		lowerCAmelCase					:    Tuple      							= text_inputs.input_ids

		if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
			lowerCAmelCase					:    str      							= self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]    )
			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}"    )
			lowerCAmelCase					:    Union[str, Any]      							= text_input_ids[:, : self.tokenizer.model_max_length]
		lowerCAmelCase					:    Union[str, Any]      							= self.text_encoder(text_input_ids.to(self.device    )    )[0]

		# duplicate text embeddings for each generation per prompt, using mps friendly method
		lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase					:    int      							= text_embeddings.shape
		lowerCAmelCase					:    Any      							= text_embeddings.repeat(1 ,					snake_case__ ,					1    )
		lowerCAmelCase					:    Optional[int]      							= text_embeddings.view(bs_embed * num_images_per_prompt ,					snake_case__ ,					-1    )

		# 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.
		lowerCAmelCase					:    List[str]      							= guidance_scale > 1.0
		# get unconditional embeddings for classifier free guidance
		if do_classifier_free_guidance:
			lowerCAmelCase					:    List[str]
			if negative_prompt is None:
				lowerCAmelCase					:    Any      							= [''] * 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__    ):
				lowerCAmelCase					:    Union[str, Any]      							= [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:
				lowerCAmelCase					:    Dict      							= negative_prompt

			lowerCAmelCase					:    Optional[int]      							= text_input_ids.shape[-1]
			lowerCAmelCase					:    int      							= self.tokenizer(
			    snake_case__ ,					padding='max_length' ,					max_length=snake_case__ ,					truncation=snake_case__ ,					return_tensors='pt' ,					)
			lowerCAmelCase					:    Union[str, Any]      							= self.text_encoder(uncond_input.input_ids.to(self.device    )    )[0]

			# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
			lowerCAmelCase					:    List[Any]      							= uncond_embeddings.shape[1]
			lowerCAmelCase					:    List[str]      							= uncond_embeddings.repeat(1 ,					snake_case__ ,					1    )
			lowerCAmelCase					:    Optional[Any]      							= uncond_embeddings.view(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
			lowerCAmelCase					:    List[str]      							= torch.cat([uncond_embeddings, text_embeddings]    )

		# get the initial random noise unless the user supplied it

		# Unlike in other pipelines, latents need to be generated in the target device
		# for 1-to-1 results reproducibility with the CompVis implementation.
		# However this currently doesn't work in `mps`.
		lowerCAmelCase					:    Union[str, Any]      							= (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
		lowerCAmelCase					:    Dict      							= text_embeddings.dtype
		if latents is None:
			if self.device.type == "mps":
				# randn does not exist on mps
				lowerCAmelCase					:    str      							= torch.randn(snake_case__ ,					generator=snake_case__ ,					device='cpu' ,					dtype=snake_case__    ).to(
				    self.device    )
			else:
				lowerCAmelCase					:    Tuple      							= torch.randn(snake_case__ ,					generator=snake_case__ ,					device=self.device ,					dtype=snake_case__    )
		else:
			if latents.shape != latents_shape:
				raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}"    )
			lowerCAmelCase					:    str      							= latents.to(self.device    )

		# set timesteps
		self.scheduler.set_timesteps(snake_case__    )

		# Some schedulers like PNDM have timesteps as arrays
		# It's more optimized to move all timesteps to correct device beforehand
		lowerCAmelCase					:    Union[str, Any]      							= self.scheduler.timesteps.to(self.device    )

		# scale the initial noise by the standard deviation required by the scheduler
		lowerCAmelCase					:    Any      							= latents * self.scheduler.init_noise_sigma

		# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
		# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
		# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
		# and should be between [0, 1]
		lowerCAmelCase					:    Tuple      							= 'eta' in set(inspect.signature(self.scheduler.step    ).parameters.keys()    )
		lowerCAmelCase					:    Union[str, Any]      							= {}
		if accepts_eta:
			lowerCAmelCase					:    int      							= eta

		for i, t in enumerate(self.progress_bar(snake_case__    )    ):
			# expand the latents if we are doing classifier free guidance
			lowerCAmelCase					:    Dict      							= torch.cat([latents] * 2    ) if do_classifier_free_guidance else latents
			lowerCAmelCase					:    Tuple      							= self.scheduler.scale_model_input(snake_case__ ,					snake_case__    )

			# predict the noise residual
			lowerCAmelCase					:    List[str]      							= self.unet(snake_case__ ,					snake_case__ ,					encoder_hidden_states=snake_case__    ).sample

			# perform guidance
			if do_classifier_free_guidance:
				lowerCAmelCase							,   lowerCAmelCase					:    Dict      							= noise_pred.chunk(2    )
				lowerCAmelCase					:    Tuple      							= noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

			# compute the previous noisy sample x_t -> x_t-1
			lowerCAmelCase					:    int      							= self.scheduler.step(snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ).prev_sample

			# call the callback, if provided
			if callback is not None and i % callback_steps == 0:
				callback(snake_case__ ,					snake_case__ ,					snake_case__    )

		lowerCAmelCase					:    List[Any]      							= 1 / 0.1_8_2_1_5 * latents
		lowerCAmelCase					:    Dict      							= self.vae.decode(snake_case__    ).sample

		lowerCAmelCase					:    List[Any]      							= (image / 2 + 0.5).clamp(0 ,					1    )

		# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
		lowerCAmelCase					:    Union[str, Any]      							= image.cpu().permute(0 ,					2 ,					3 ,					1    ).float().numpy()

		if output_type == "pil":
			lowerCAmelCase					:    Dict      							= self.numpy_to_pil(snake_case__    )

		if not return_dict:
			return image

		return StableDiffusionPipelineOutput(images=snake_case__ ,					nsfw_content_detected=snake_case__    )
