

"""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 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			Optional[int]	):
    with tempfile.TemporaryDirectory() as tmpdirname:
       # pipeline has Flax weights
       __lowercase								=						FlaxDiffusionPipeline.from_pretrained(
           "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=UpperCAmelCase__,					cache_dir=UpperCAmelCase__	)

       __lowercase								=						[t[-1] for t in os.walk(os.path.join(UpperCAmelCase__,					os.listdir(UpperCAmelCase__	)[0],					"snapshots"	)	)]
       __lowercase								=						[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 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			List[Any]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=UpperCAmelCase__	)

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

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						4

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).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.1_514_745	) < 1E-3
       assert np.abs(np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 49_947.875	) < 5E-1

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


 def 					_lowercase (			self							:			int	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="flax",					safety_checker=UpperCAmelCase__	)

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

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).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.05_652_401)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_383_808.2)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__	)

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

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).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.04_003_906)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_373_516.75)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa	)

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

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).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.04_003_906)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_373_516.75)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase								=						FlaxDDIMScheduler(
        beta_start=0.00_085,					beta_end=0.012,					beta_schedule="scaled_linear",					set_alpha_to_one=UpperCAmelCase__,					steps_offset=1,					)

    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					scheduler=UpperCAmelCase__,					safety_checker=UpperCAmelCase__,					)
    __lowercase								=						scheduler.create_state()

    __lowercase								=						scheduler_state

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

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).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.045_043_945)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_347_693.5)	) < 5E-1



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

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						jax.random.split(jax.random.PRNGKey(0	),					UpperCAmelCase__	)

    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__,					)

    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)
    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images
    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    __lowercase								=						images[2, 0, 2_5_6, 1_0:1_7, 1]

    # With memory efficient attention
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__,					use_memory_efficient_attention=UpperCAmelCase__,					)

    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)
    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images
    assert images_eff.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    __lowercase								=						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'''




def 				snake_case__							(			_A:					str )    ->	list[int]:

		'''simple docstring'''


		lowerCAmelCase   					=  [0 for i in range(len(_A ) )]

		# initialize interval's left pointer and right pointer
		lowerCAmelCase					,     lowerCAmelCase   					=  0, 0

		for i in range(1      ,   len(_A ) ):
				# case when current index is inside the interval
				if i <= right_pointer:
						lowerCAmelCase   					=  min(right_pointer - i + 1      ,   z_result[i - left_pointer] )
						lowerCAmelCase   					=  min_edge

				while go_next(_A      ,   _A      ,   _A ):
						z_result[i] += 1

				# if new index's result gives us more right interval,
				# we've to update left_pointer and right_pointer
				if i + z_result[i] - 1 > right_pointer:
						lowerCAmelCase					,     lowerCAmelCase   					=  i, i + z_result[i] - 1

		return z_result






def 				snake_case__							(			_A:					int      ,   _A:					list[int]      ,   _A:					str )    ->	bool:

		'''simple docstring'''


		return i + z_result[i] < len(_A ) and s[z_result[i]] == s[i + z_result[i]]






def 				snake_case__							(			_A:					str      ,   _A:					str )    ->	int:

		'''simple docstring'''


		lowerCAmelCase   					=  0
		# concatenate 'pattern' and 'input_str' and call z_function
		# with concatenated string
		lowerCAmelCase   					=  z_function(pattern + input_str )

		for val in z_result:
				# if value is greater then length of the pattern string
				# that means this index is starting position of substring
				# which is equal to pattern string
				if val >= len(_A ):
						answer += 1

		return answer


if __name__ == "__main__":
						import doctest

						doctest.testmod()




