






"""simple docstring"""





import os
import tempfile
import unittest

import numpy as np

from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax, slow


if is_flax_available():
							import jax
							import jax.numpy as jnp
							from flax.jax_utils import replicate
							from flax.training.common_utils import shard

							from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline



@require_flax
class       __A		(   unittest.TestCase			):

					def   lowerCamelCase__   (			self  :      List[str]					)			->							Dict:
											with tempfile.TemporaryDirectory() as tmpdirname:
																	# pipeline has Flax weights
																	__magic_name__:	List[Any]							=       FlaxDiffusionPipeline.from_pretrained(
																	    """hf-internal-testing/tiny-stable-diffusion-pipe"""     ,		safety_checker=__snake_case     ,		cache_dir=__snake_case					)

																	__magic_name__:	List[str]							=       [t[-1] for t in os.walk(os.path.join(__snake_case     ,		os.listdir(__snake_case					)[0]     ,		"""snapshots"""					)					)]
																	__magic_name__:	Tuple							=       [item for sublist in all_root_files for item in sublist]

																	# None of the downloaded files should be a PyTorch file even if we have some here:
																	# https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
																	assert not any(f.endswith(""".bin"""					) for f in files					)



@slow
@require_flax
class       __A		(   unittest.TestCase			):

					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Tuple:
											__magic_name__,			__magic_name__:	Optional[Any]							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-pipe"""     ,		safety_checker=__snake_case					)

											__magic_name__:	List[str]							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	str							=       jax.random.PRNGKey(0					)
											__magic_name__:	Optional[int]							=       4

											__magic_name__:	List[str]							=       jax.device_count()
											__magic_name__:	Dict							=       num_samples * [prompt]
											__magic_name__:	List[str]							=       pipeline.prepare_inputs(__snake_case					)

											# shard inputs and rng
											__magic_name__:	Tuple							=       replicate(__snake_case					)
											__magic_name__:	List[str]							=       jax.random.split(__snake_case     ,		__snake_case					)
											__magic_name__:	List[Any]							=       shard(__snake_case					)

											__magic_name__:	Dict							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images

											assert images.shape == (num_samples, 1, 6_4, 6_4, 3)
											if jax.device_count() == 8:
																	assert np.abs(np.abs(images[0, 0, :2, :2, -2:]     ,		dtype=np.floataa					).sum() - 4.1514745					) < 1E-3
																	assert np.abs(np.abs(__snake_case     ,		dtype=np.floataa					).sum() - 49947.875					) < 5E-1

											__magic_name__:	str							=       pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]					)					)					)
											assert len(__snake_case					) == num_samples

					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							Any:
											__magic_name__,			__magic_name__:	Optional[int]							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""flax"""     ,		safety_checker=__snake_case					)

											__magic_name__:	List[Any]							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	Dict							=       jax.random.PRNGKey(0					)
											__magic_name__:	int							=       5_0

											__magic_name__:	int							=       jax.device_count()
											__magic_name__:	str							=       num_samples * [prompt]
											__magic_name__:	str							=       pipeline.prepare_inputs(__snake_case					)

											# shard inputs and rng
											__magic_name__:	List[Any]							=       replicate(__snake_case					)
											__magic_name__:	int							=       jax.random.split(__snake_case     ,		__snake_case					)
											__magic_name__:	Tuple							=       shard(__snake_case					)

											__magic_name__:	Tuple							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images

											assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											if jax.device_count() == 8:
																	assert np.abs((np.abs(images[0, 0, :2, :2, -2:]     ,		dtype=np.floataa					).sum() - 0.05652401)					) < 1E-3
																	assert np.abs((np.abs(__snake_case     ,		dtype=np.floataa					).sum() - 2383808.2)					) < 5E-1

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Any:
											__magic_name__,			__magic_name__:	Optional[int]							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""bf16"""     ,		dtype=jnp.bfloataa     ,		safety_checker=__snake_case					)

											__magic_name__:	str							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	List[str]							=       jax.random.PRNGKey(0					)
											__magic_name__:	Optional[int]							=       5_0

											__magic_name__:	Tuple							=       jax.device_count()
											__magic_name__:	Dict							=       num_samples * [prompt]
											__magic_name__:	Dict							=       pipeline.prepare_inputs(__snake_case					)

											# shard inputs and rng
											__magic_name__:	List[str]							=       replicate(__snake_case					)
											__magic_name__:	Tuple							=       jax.random.split(__snake_case     ,		__snake_case					)
											__magic_name__:	Optional[Any]							=       shard(__snake_case					)

											__magic_name__:	List[Any]							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images

											assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											if jax.device_count() == 8:
																	assert np.abs((np.abs(images[0, 0, :2, :2, -2:]     ,		dtype=np.floataa					).sum() - 0.04003906)					) < 1E-3
																	assert np.abs((np.abs(__snake_case     ,		dtype=np.floataa					).sum() - 2373516.75)					) < 5E-1

					def   lowerCamelCase__   (			self  :      Any					)			->							Union[str, Any]:
											__magic_name__,			__magic_name__:	Optional[int]							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""bf16"""     ,		dtype=jnp.bfloataa					)

											__magic_name__:	str							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	Dict							=       jax.random.PRNGKey(0					)
											__magic_name__:	Union[str, Any]							=       5_0

											__magic_name__:	Optional[Any]							=       jax.device_count()
											__magic_name__:	int							=       num_samples * [prompt]
											__magic_name__:	Union[str, Any]							=       pipeline.prepare_inputs(__snake_case					)

											# shard inputs and rng
											__magic_name__:	Optional[Any]							=       replicate(__snake_case					)
											__magic_name__:	Any							=       jax.random.split(__snake_case     ,		__snake_case					)
											__magic_name__:	Optional[int]							=       shard(__snake_case					)

											__magic_name__:	Optional[int]							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images

											assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											if jax.device_count() == 8:
																	assert np.abs((np.abs(images[0, 0, :2, :2, -2:]     ,		dtype=np.floataa					).sum() - 0.04003906)					) < 1E-3
																	assert np.abs((np.abs(__snake_case     ,		dtype=np.floataa					).sum() - 2373516.75)					) < 5E-1

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Dict:
											__magic_name__:	Union[str, Any]							=       FlaxDDIMScheduler(
											    beta_start=0.00085     ,		beta_end=0.012     ,		beta_schedule="""scaled_linear"""     ,		set_alpha_to_one=__snake_case     ,		steps_offset=1     ,		)

											__magic_name__,			__magic_name__:	str							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""bf16"""     ,		dtype=jnp.bfloataa     ,		scheduler=__snake_case     ,		safety_checker=__snake_case     ,		)
											__magic_name__:	Dict							=       scheduler.create_state()

											__magic_name__:	List[str]							=       scheduler_state

											__magic_name__:	Optional[Any]							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	Optional[Any]							=       jax.random.PRNGKey(0					)
											__magic_name__:	List[Any]							=       5_0

											__magic_name__:	Tuple							=       jax.device_count()
											__magic_name__:	Union[str, Any]							=       num_samples * [prompt]
											__magic_name__:	Any							=       pipeline.prepare_inputs(__snake_case					)

											# shard inputs and rng
											__magic_name__:	List[str]							=       replicate(__snake_case					)
											__magic_name__:	List[str]							=       jax.random.split(__snake_case     ,		__snake_case					)
											__magic_name__:	Dict							=       shard(__snake_case					)

											__magic_name__:	Optional[Any]							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images

											assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											if jax.device_count() == 8:
																	assert np.abs((np.abs(images[0, 0, :2, :2, -2:]     ,		dtype=np.floataa					).sum() - 0.045043945)					) < 1E-3
																	assert np.abs((np.abs(__snake_case     ,		dtype=np.floataa					).sum() - 2347693.5)					) < 5E-1






					def   lowerCamelCase__   (			self  :      Tuple					)			->							List[str]:
											__magic_name__:	List[Any]							=       (
											    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
											    """ field, close up, split lighting, cinematic"""
											)

											__magic_name__:	Union[str, Any]							=       jax.device_count()
											__magic_name__:	List[str]							=       num_samples * [prompt]
											__magic_name__:	List[str]							=       jax.random.split(jax.random.PRNGKey(0					)     ,		__snake_case					)

											__magic_name__,			__magic_name__:	int							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""bf16"""     ,		dtype=jnp.bfloataa     ,		safety_checker=__snake_case     ,		)

											__magic_name__:	str							=       replicate(__snake_case					)
											__magic_name__:	List[Any]							=       pipeline.prepare_inputs(__snake_case					)
											__magic_name__:	Optional[Any]							=       shard(__snake_case					)
											__magic_name__:	Any							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images
											assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											__magic_name__:	Optional[int]							=       images[2, 0, 2_5_6, 1_0:1_7, 1]

											# With memory efficient attention
											__magic_name__,			__magic_name__:	Optional[int]							=       FlaxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""     ,		revision="""bf16"""     ,		dtype=jnp.bfloataa     ,		safety_checker=__snake_case     ,		use_memory_efficient_attention=__snake_case     ,		)

											__magic_name__:	Union[str, Any]							=       replicate(__snake_case					)
											__magic_name__:	List[str]							=       pipeline.prepare_inputs(__snake_case					)
											__magic_name__:	Dict							=       shard(__snake_case					)
											__magic_name__:	List[Any]							=       pipeline(__snake_case     ,		__snake_case     ,		__snake_case     ,		jit=__snake_case					).images
											assert images_eff.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
											__magic_name__:	Tuple							=       images[2, 0, 2_5_6, 1_0:1_7, 1]

											# I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
											# over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
											assert abs(slice_eff - slice					).max() < 1E-2











"""simple docstring"""





from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


__lowerCamelCase							=  logging.get_logger(__name__)



class       __A		(   SCREAMING_SNAKE_CASE_			):

					def __init__(			self  :      Union[str, Any]     ,		__snake_case  :      int     ,		__snake_case  :      int     ,		__snake_case  :      float     ,		**__snake_case  :      Optional[Any]					)			->							str:
											__magic_name__:	Optional[Any]							=       feature_size
											__magic_name__:	List[Any]							=       sampling_rate
											__magic_name__:	Tuple							=       padding_value

											__magic_name__:	int							=       kwargs.pop("""padding_side"""     ,		"""right"""					)
											__magic_name__:	Optional[Any]							=       kwargs.pop("""return_attention_mask"""     ,		__snake_case					)

											super().__init__(**__snake_case					)

					def   lowerCamelCase__   (			self  :      Union[str, Any]     ,		__snake_case  :      Union[
					        BatchFeature,
					        List[BatchFeature],
					        Dict[str, BatchFeature],
					        Dict[str, List[BatchFeature]],
					        List[Dict[str, BatchFeature]],
					    ]     ,		__snake_case  :      Union[bool, str, PaddingStrategy] = True     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      bool = False     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		__snake_case  :      Optional[Union[str, TensorType]] = None     ,		)			->							BatchFeature:
											# If we have a list of dicts, let's convert it in a dict of lists
											# We do this to allow using this method as a collate_fn function in PyTorch Dataloader
											if isinstance(__snake_case     ,		(list, tuple)					) and isinstance(processed_features[0]     ,		(dict, BatchFeature)					):
																	__magic_name__:	Union[str, Any]							=       {
																	    key: [example[key] for example in processed_features] for key in processed_features[0].keys()
																	}

											# The model's main input name, usually `input_values`, has be passed for padding
											if self.model_input_names[0] not in processed_features:
																	raise ValueError(
																	    """You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`"""
																	    F' to this method that includes {self.model_input_names[0]}, but you provided'
																	    F' {list(processed_features.keys()					)}'					)

											__magic_name__:	Any							=       processed_features[self.model_input_names[0]]
											__magic_name__:	Tuple							=       (
											    return_attention_mask if return_attention_mask is not None else self.return_attention_mask
											)

											if len(__snake_case					) == 0:
																	if return_attention_mask:
																							__magic_name__:	Optional[Any]							=       []
																	return processed_features

											# If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
											# and rebuild them afterwards if no return_tensors is specified
											# Note that we lose the specific device the tensor may be on for PyTorch

											__magic_name__:	Tuple							=       required_input[0]
											if isinstance(__snake_case     ,		(list, tuple)					):
																	# first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
																	__magic_name__:	str							=       0
																	while len(required_input[index]					) == 0:
																							index += 1
																	if index < len(__snake_case					):
																							__magic_name__:	Optional[int]							=       required_input[index][0]

											if return_tensors is None:
																	if is_tf_tensor(__snake_case					):
																							__magic_name__:	List[str]							=       """tf"""
																	elif is_torch_tensor(__snake_case					):
																							__magic_name__:	Any							=       """pt"""
																	elif isinstance(__snake_case     ,		(int, float, list, tuple, np.ndarray)					):
																							__magic_name__:	int							=       """np"""
																	else:
																							raise ValueError(
																							    F'type of {first_element} unknown: {type(__snake_case					)}. '
																							    """Should be one of a python, numpy, pytorch or tensorflow object."""					)

											for key, value in processed_features.items():
																	if isinstance(value[0]     ,		(int, float)					):
																							__magic_name__:	List[str]							=       to_numpy(__snake_case					)
																	else:
																							__magic_name__:	Any							=       [to_numpy(__snake_case					) for v in value]

        # Convert padding_strategy in PaddingStrategy
											__magic_name__:	str							=       self._get_padding_strategies(padding=__snake_case     ,		max_length=__snake_case					)

											__magic_name__:	str							=       processed_features[self.model_input_names[0]]

											__magic_name__:	str							=       len(__snake_case					)
											if not all(len(__snake_case					) == batch_size for v in processed_features.values()					):
																	raise ValueError("""Some items in the output dictionary have a different batch size than others."""					)

											__magic_name__:	List[Any]							=       []
											for i in range(__snake_case					):
																	__magic_name__:	List[Any]							=       {k: v[i] for k, v in processed_features.items()}
																	# truncation
																	__magic_name__:	List[Any]							=       self._truncate(
																	    __snake_case     ,		max_length=__snake_case     ,		pad_to_multiple_of=__snake_case     ,		truncation=__snake_case     ,		)
																	truncated_inputs.append(__snake_case					)

											if padding_strategy == PaddingStrategy.LONGEST:
																	# make sure that `max_length` cannot be longer than the longest truncated length
																	__magic_name__:	Union[str, Any]							=       max(len(input_slice[self.model_input_names[0]]					) for input_slice in truncated_inputs					)
																	__magic_name__:	Union[str, Any]							=       PaddingStrategy.MAX_LENGTH

											__magic_name__:	List[str]							=       {}
											for i in range(__snake_case					):
																	# padding
																	__magic_name__:	str							=       self._pad(
																	    truncated_inputs[i]     ,		max_length=__snake_case     ,		padding_strategy=__snake_case     ,		pad_to_multiple_of=__snake_case     ,		return_attention_mask=__snake_case     ,		)

																	for key, value in outputs.items():
																							if key not in batch_outputs:
																													__magic_name__:	Optional[Any]							=       []
																							if value.dtype is np.dtype(np.floataa					):
																													__magic_name__:	Any							=       value.astype(np.floataa					)
																							batch_outputs[key].append(__snake_case					)

											return BatchFeature(__snake_case     ,		tensor_type=__snake_case					)

					def   lowerCamelCase__   (			self  :      Tuple     ,		__snake_case  :      Union[Dict[str, np.ndarray], BatchFeature]     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      PaddingStrategy = PaddingStrategy.DO_NOT_PAD     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		)			->							dict:
											__magic_name__:	List[str]							=       processed_features[self.model_input_names[0]]

											if padding_strategy == PaddingStrategy.LONGEST:
																	__magic_name__:	List[Any]							=       len(__snake_case					)

											if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
																	__magic_name__:	List[str]							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

											__magic_name__:	str							=       padding_strategy != PaddingStrategy.DO_NOT_PAD and len(__snake_case					) < max_length

											if return_attention_mask and "attention_mask" not in processed_features:
																	__magic_name__:	int							=       np.ones(len(__snake_case					)     ,		dtype=np.intaa					)

											if needs_to_be_padded:
																	__magic_name__:	str							=       max_length - len(__snake_case					)
																	if self.padding_side == "right":
																							if return_attention_mask:
																													__magic_name__:	List[Any]							=       np.pad(
																													    processed_features["""attention_mask"""]     ,		(0, difference)					)
																							__magic_name__:	Union[str, Any]							=       ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
																							__magic_name__:	int							=       np.pad(
																							    __snake_case     ,		__snake_case     ,		"""constant"""     ,		constant_values=self.padding_value					)
																	elif self.padding_side == "left":
																							if return_attention_mask:
																													__magic_name__:	Dict							=       np.pad(
																													    processed_features["""attention_mask"""]     ,		(difference, 0)					)
																							__magic_name__:	Optional[Any]							=       ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
																							__magic_name__:	int							=       np.pad(
																							    __snake_case     ,		__snake_case     ,		"""constant"""     ,		constant_values=self.padding_value					)
																	else:
																							raise ValueError("""Invalid padding strategy:""" + str(self.padding_side					)					)

											return processed_features

					def   lowerCamelCase__   (			self  :      Optional[Any]     ,		__snake_case  :      Union[Dict[str, np.ndarray], BatchFeature]     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		)			->							int:
											if not truncation:
																	return processed_features
											elif truncation and max_length is None:
																	raise ValueError("""When setting ``truncation=True``, make sure that ``max_length`` is defined."""					)

											__magic_name__:	Dict							=       processed_features[self.model_input_names[0]]

											# find `max_length` that fits `pad_to_multiple_of`
											if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
																	__magic_name__:	Optional[Any]							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

											__magic_name__:	Tuple							=       len(__snake_case					) > max_length

											if needs_to_be_truncated:
																	__magic_name__:	Any							=       processed_features[self.model_input_names[0]][:max_length]
																	if "attention_mask" in processed_features:
																							__magic_name__:	List[Any]							=       processed_features["""attention_mask"""][:max_length]

											return processed_features






					def   lowerCamelCase__   (			self  :      List[Any]     ,		__snake_case  :      int=False     ,		__snake_case  :      Tuple=None					)			->							Optional[Any]:

											# Get padding strategy
											if padding is not False:
																	if padding is True:
																							__magic_name__:	Optional[Any]							=       PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
																	elif not isinstance(__snake_case     ,		__snake_case					):
																							__magic_name__:	Tuple							=       PaddingStrategy(__snake_case					)
																	elif isinstance(__snake_case     ,		__snake_case					):
																							__magic_name__:	Dict							=       padding
											else:
																	__magic_name__:	int							=       PaddingStrategy.DO_NOT_PAD

											# Set max length if needed
											if max_length is None:
																	if padding_strategy == PaddingStrategy.MAX_LENGTH:
																							raise ValueError(
																							    F'When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined'					)

        # Test if we have a padding value
											if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
																	raise ValueError(
																	    """Asking to pad but the feature_extractor does not have a padding value. Please select a value to use"""
																	    """ as `padding_value`. For example: `feature_extractor.padding_value = 0.0`."""					)

											return padding_strategy



