






import gc
import unittest

from parameterized import parameterized

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


if is_flax_available():
      import jax
      import jax.numpy as jnp







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




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase	,						_lowerCAmelCase		):
          return f"gaussian_noise_s={seed}_shape={'_'.join([str(_lowerCAmelCase		) for s in shape]		)}.npy"




     def   __UpperCAmelCase  (				self		):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase=0	,						_lowerCAmelCase=(4, 4, 64, 64)	,						_lowerCAmelCase=False		):
          UpperCAmelCase__      :  Optional[Any]				      =			jnp.bfloataa if fpaa else jnp.floataa
          UpperCAmelCase__      :  Union[str, Any]				      =			jnp.array(load_hf_numpy(self.get_file_format(_lowerCAmelCase	,						_lowerCAmelCase		)		)	,						dtype=_lowerCAmelCase		)
          return image




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase=False	,						_lowerCAmelCase="CompVis/stable-diffusion-v1-4"		):
          UpperCAmelCase__      :  int				      =			jnp.bfloataa if fpaa else jnp.floataa
          UpperCAmelCase__      :  Optional[Any]				      =			"""bf16""" if fpaa else None

          UpperCAmelCase__      ,		UpperCAmelCase__      :  Optional[Any]				      =			FlaxUNetaDConditionModel.from_pretrained(
              _lowerCAmelCase	,						subfolder="""unet"""	,						dtype=_lowerCAmelCase	,						revision=_lowerCAmelCase		)
          return model, params




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase=0	,						_lowerCAmelCase=(4, 77, 768)	,						_lowerCAmelCase=False		):
          UpperCAmelCase__      :  Optional[int]				      =			jnp.bfloataa if fpaa else jnp.floataa
          UpperCAmelCase__      :  Optional[int]				      =			jnp.array(load_hf_numpy(self.get_file_format(_lowerCAmelCase	,						_lowerCAmelCase		)		)	,						dtype=_lowerCAmelCase		)
          return hidden_states




     @parameterized.expand(
         [
             # fmt: off
             [83, 4, [-0.2_3_2_3, -0.1_3_0_4, 0.0_8_1_3, -0.3_0_9_3, -0.0_9_1_9, -0.1_5_7_1, -0.1_1_2_5, -0.5_8_0_6]],
             [17, 0.5_5, [-0.0_8_3_1, -0.2_4_4_3, 0.0_9_0_1, -0.0_9_1_9, 0.3_3_9_6, 0.0_1_0_3, -0.3_7_4_3, 0.0_7_0_1]],
             [8, 0.8_9, [-0.4_8_6_3, 0.0_8_5_9, 0.0_8_7_5, -0.1_6_5_8, 0.9_1_9_9, -0.0_1_1_4, 0.4_8_3_9, 0.4_6_3_9]],
             [3, 1000, [-0.5_6_4_9, 0.2_4_0_2, -0.5_5_1_8, 0.1_2_4_8, 1.1_3_2_8, -0.2_4_4_3, -0.0_3_2_5, -1.0_0_7_8]],
             # fmt: on
         ]		)
     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase	,						_lowerCAmelCase	,						_lowerCAmelCase		):
          UpperCAmelCase__      ,		UpperCAmelCase__      :  Optional[Any]				      =			self.get_unet_model(model_id="""CompVis/stable-diffusion-v1-4"""	,						fpaa=_lowerCAmelCase		)
          UpperCAmelCase__      :  Union[str, Any]				      =			self.get_latents(_lowerCAmelCase	,						fpaa=_lowerCAmelCase		)
          UpperCAmelCase__      :  Dict				      =			self.get_encoder_hidden_states(_lowerCAmelCase	,						fpaa=_lowerCAmelCase		)

          UpperCAmelCase__      :  Optional[Any]				      =			model.apply(
              {"""params""": params}	,						_lowerCAmelCase	,						jnp.array(_lowerCAmelCase	,						dtype=jnp.intaa		)	,						encoder_hidden_states=_lowerCAmelCase	,						).sample

          assert sample.shape == latents.shape

          UpperCAmelCase__      :  Dict				      =			jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())		)	,						dtype=jnp.floataa		)
          UpperCAmelCase__      :  List[Any]				      =			jnp.array(_lowerCAmelCase	,						dtype=jnp.floataa		)

          # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
          assert jnp.allclose(_lowerCAmelCase	,						_lowerCAmelCase	,						atol=1e-2		)




     @parameterized.expand(
         [
             # fmt: off
             [83, 4, [0.1_5_1_4, 0.0_8_0_7, 0.1_6_2_4, 0.1_0_1_6, -0.1_8_9_6, 0.0_2_6_3, 0.0_6_7_7, 0.2_3_1_0]],
             [17, 0.5_5, [0.1_1_6_4, -0.0_2_1_6, 0.0_1_7_0, 0.1_5_8_9, -0.3_1_2_0, 0.1_0_0_5, -0.0_5_8_1, -0.1_4_5_8]],
             [8, 0.8_9, [-0.1_7_5_8, -0.0_1_6_9, 0.1_0_0_4, -0.1_4_1_1, 0.1_3_1_2, 0.1_1_0_3, -0.1_9_9_6, 0.2_1_3_9]],
             [3, 1000, [0.1_2_1_4, 0.0_3_5_2, -0.0_7_3_1, -0.1_5_6_2, -0.0_9_9_4, -0.0_9_0_6, -0.2_3_4_0, -0.0_5_3_9]],
             # fmt: on
         ]		)
     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase	,						_lowerCAmelCase	,						_lowerCAmelCase		):
          UpperCAmelCase__      ,		UpperCAmelCase__      :  Tuple				      =			self.get_unet_model(model_id="""stabilityai/stable-diffusion-2"""	,						fpaa=_lowerCAmelCase		)
          UpperCAmelCase__      :  Union[str, Any]				      =			self.get_latents(_lowerCAmelCase	,						shape=(4, 4, 96, 96)	,						fpaa=_lowerCAmelCase		)
          UpperCAmelCase__      :  Any				      =			self.get_encoder_hidden_states(_lowerCAmelCase	,						shape=(4, 77, 1024)	,						fpaa=_lowerCAmelCase		)

          UpperCAmelCase__      :  Dict				      =			model.apply(
              {"""params""": params}	,						_lowerCAmelCase	,						jnp.array(_lowerCAmelCase	,						dtype=jnp.intaa		)	,						encoder_hidden_states=_lowerCAmelCase	,						).sample

          assert sample.shape == latents.shape

          UpperCAmelCase__      :  Any				      =			jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())		)	,						dtype=jnp.floataa		)
          UpperCAmelCase__      :  Any				      =			jnp.array(_lowerCAmelCase	,						dtype=jnp.floataa		)

          # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
          assert jnp.allclose(_lowerCAmelCase	,						_lowerCAmelCase	,						atol=1e-2		)









UpperCAmelCase_							:					dict[tuple[int, int, int], int]		 =   {}
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int			,a__    :   int			,a__    :   int       )					->				int:

	# if we are absent twice, or late 3 consecutive days,
	# no further prize strings are possible
	if late == 3 or absent == 2:
		return 0

	# if we have no days left, and have not failed any other rules,
	# we have a prize string
	if days == 0:
		return 1

	# No easy solution, so now we need to do the recursive calculation

	# First, check if the combination is already in the cache, and
	# if yes, return the stored value from there since we already
	# know the number of possible prize strings from this point on
	__A :			List[Any]		    =			(days, absent, late)
	if key in cache:
		return cache[key]

	# now we calculate the three possible ways that can unfold from
	# this point on, depending on our attendance today

	# 1) if we are late (but not absent), the "absent" counter stays as
	# it is, but the "late" counter increases by one
	__A :			Dict		    =			_calculate(days - 1			,a__			,late + 1       )

	# 2) if we are absent, the "absent" counter increases by 1, and the
	# "late" counter resets to 0
	__A :			List[str]		    =			_calculate(days - 1			,absent + 1			,0       )

	# 3) if we are on time, this resets the "late" counter and keeps the
	# absent counter
	__A :			int		    =			_calculate(days - 1			,a__			,0       )

	__A :			Optional[int]		    =			state_late + state_absent + state_ontime

	__A :			Tuple		    =			prizestrings
	return prizestrings
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int = 30       )					->				int:
	return _calculate(a__			,absent=0			,late=0       )


if __name__ == "__main__":
			print(solution())





