"""simple docstring"""







import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
       import onnxruntime as ort







class        UpperCamelCase		(			lowercase_						,      unittest.TestCase  ):
   lowercase							=  'hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase=0			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				List[str]													=	floats_tensor((1, 3, 128, 128)     ,rng=random.Random(__UpperCamelCase			)			)
        lowercase_	:				List[str]													=	np.random.RandomState(__UpperCamelCase			)
        lowercase_	:				Union[str, Any]													=	{
            'prompt': 'A painting of a squirrel eating a burger',
            'image': image,
            'generator': generator,
            'num_inference_steps': 3,
            'strength': 0.75,
            'guidance_scale': 7.5,
            'output_type': 'numpy',
        }
        return inputs
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				int													=	self.get_dummy_inputs()
        lowercase_	:				Dict													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				str													=	image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				Tuple													=	np.array([0.6_9643, 0.5_8484, 0.5_0314, 0.5_8760, 0.5_5368, 0.5_9643, 0.5_1529, 0.4_1217, 0.4_9087]			)
        assert np.abs(image_slice - expected_slice			).max() < 1e-1
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				str													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        lowercase_	:				str													=	PNDMScheduler.from_config(pipe.scheduler.config     ,skip_prk_steps=__UpperCamelCase			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				Optional[Any]													=	self.get_dummy_inputs()
        lowercase_	:				Union[str, Any]													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				Optional[int]													=	image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				Optional[Any]													=	np.array([0.6_1737, 0.5_4642, 0.5_3183, 0.5_4465, 0.5_2742, 0.6_0525, 0.4_9969, 0.4_0655, 0.4_8154]			)

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-1
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				Any													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        lowercase_	:				Tuple													=	LMSDiscreteScheduler.from_config(pipe.scheduler.config			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        # warmup pass to apply optimizations
        lowercase_	:				Union[str, Any]													=	pipe(**self.get_dummy_inputs()			)

        lowercase_	:				List[str]													=	self.get_dummy_inputs()
        lowercase_	:				Dict													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				int													=	image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				str													=	np.array([0.5_2761, 0.5_9977, 0.4_9033, 0.4_9619, 0.5_4282, 0.5_0311, 0.4_7600, 0.4_0918, 0.4_5203]			)

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-1
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Tuple													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        lowercase_	:				Any													=	EulerDiscreteScheduler.from_config(pipe.scheduler.config			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				Optional[int]													=	self.get_dummy_inputs()
        lowercase_	:				Optional[Any]													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				List[Any]													=	image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				Tuple													=	np.array([0.5_2911, 0.6_0004, 0.4_9229, 0.4_9805, 0.5_4502, 0.5_0680, 0.4_7777, 0.4_1028, 0.4_5304]			)

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-1
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        lowercase_	:				Optional[int]													=	EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				List[Any]													=	self.get_dummy_inputs()
        lowercase_	:				List[str]													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				str													=	image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				List[Any]													=	np.array([0.5_2911, 0.6_0004, 0.4_9229, 0.4_9805, 0.5_4502, 0.5_0680, 0.4_7777, 0.4_1028, 0.4_5304]			)

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-1







   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,provider='CPUExecutionProvider'			)
        lowercase_	:				Optional[Any]													=	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				Optional[Any]													=	self.get_dummy_inputs()
        lowercase_	:				int													=	pipe(**__UpperCamelCase			).images
        lowercase_	:				Optional[Any]													=	image[0, -3:, -3:, -1]

        assert image.shape == (1, 128, 128, 3)
        lowercase_	:				List[Any]													=	np.array([0.6_5331, 0.5_8277, 0.4_8204, 0.5_6059, 0.5_3665, 0.5_6235, 0.5_0969, 0.4_0009, 0.4_6552]			)

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-1







@nightly
@require_onnxruntime
@require_torch_gpu
class        UpperCamelCase		(			unittest.TestCase  ):
   @property
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        return (
            "CUDAExecutionProvider",
            {
                "gpu_mem_limit": "15000000000",  # 15GB
                "arena_extend_strategy": "kSameAsRequested",
            },
        )
   @property
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				List[Any]													=	ort.SessionOptions()
        lowercase_	:				str													=	False
        return options
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
            '/img2img/sketch-mountains-input.jpg'			)
        lowercase_	:				Optional[Any]													=	init_image.resize((768, 512)			)
        # using the PNDM scheduler by default
        lowercase_	:				str													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(
            'CompVis/stable-diffusion-v1-4'     ,revision='onnx'     ,safety_checker=__UpperCamelCase     ,feature_extractor=__UpperCamelCase     ,provider=self.gpu_provider     ,sess_options=self.gpu_options     ,)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				List[Any]													=	'A fantasy landscape, trending on artstation'

        lowercase_	:				Dict													=	np.random.RandomState(0			)
        lowercase_	:				str													=	pipe(
            prompt=__UpperCamelCase     ,image=__UpperCamelCase     ,strength=0.75     ,guidance_scale=7.5     ,num_inference_steps=10     ,generator=__UpperCamelCase     ,output_type='np'     ,)
        lowercase_	:				Union[str, Any]													=	output.images
        lowercase_	:				Union[str, Any]													=	images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 768, 3)
        lowercase_	:				Any													=	np.array([0.4909, 0.5059, 0.5372, 0.4623, 0.4876, 0.5049, 0.4820, 0.4956, 0.5019]			)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 2e-2







   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
            '/img2img/sketch-mountains-input.jpg'			)
        lowercase_	:				int													=	init_image.resize((768, 512)			)
        lowercase_	:				int													=	LMSDiscreteScheduler.from_pretrained(
            'runwayml/stable-diffusion-v1-5'     ,subfolder='scheduler'     ,revision='onnx'			)
        lowercase_	:				int													=	OnnxStableDiffusionImgaImgPipeline.from_pretrained(
            'runwayml/stable-diffusion-v1-5'     ,revision='onnx'     ,scheduler=__UpperCamelCase     ,safety_checker=__UpperCamelCase     ,feature_extractor=__UpperCamelCase     ,provider=self.gpu_provider     ,sess_options=self.gpu_options     ,)
        pipe.set_progress_bar_config(disable=__UpperCamelCase			)

        lowercase_	:				Optional[Any]													=	'A fantasy landscape, trending on artstation'

        lowercase_	:				Dict													=	np.random.RandomState(0			)
        lowercase_	:				Tuple													=	pipe(
            prompt=__UpperCamelCase     ,image=__UpperCamelCase     ,strength=0.75     ,guidance_scale=7.5     ,num_inference_steps=20     ,generator=__UpperCamelCase     ,output_type='np'     ,)
        lowercase_	:				List[Any]													=	output.images
        lowercase_	:				Any													=	images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 768, 3)
        lowercase_	:				Dict													=	np.array([0.8043, 0.926, 0.9581, 0.8119, 0.8954, 0.913, 0.7209, 0.7463, 0.7431]			)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

        assert np.abs(image_slice.flatten() - expected_slice			).max() < 2e-2


"""simple docstring"""







__SCREAMING_SNAKE_CASE    	={}



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     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
     lowercase_	:				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
     lowercase_	:				Optional[int]													=	_calculate(days - 1     ,			__SCREAMING_SNAKE_CASE     ,			late + 1      )

     # 2) if we are absent, the "absent" counter increases by 1, and the
     # "late" counter resets to 0
     lowercase_	:				Any													=	_calculate(days - 1     ,			absent + 1     ,			0      )

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

     lowercase_	:				str													=	state_late + state_absent + state_ontime

     lowercase_	:				Tuple													=	prizestrings
     return prizestrings



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int = 30      ):
     return _calculate(__SCREAMING_SNAKE_CASE     ,			absent=0     ,			late=0      )


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

