






def _UpperCAmelCase   (	a						:	int = 10  ,					a						:	int = 1000  ,					a						:	bool = True ):
							assert (
							    isinstance(a  ,					a )
							    and isinstance(a  ,					a )
							    and isinstance(a  ,					a )
							), "Invalid type of value(s) specified to function!"

							if min_val > max_val:
														raise ValueError("""Invalid value for min_val or max_val (min_value < max_value)""" )
							return min_val if option else max_val

def _UpperCAmelCase   (	a						:	int  ,					a						:	int ):
							return int((number_a + number_a) / 2 )

def _UpperCAmelCase   (	a						:	int  ,					a						:	int  ,					a						:	int ):
							assert (
							    isinstance(a  ,					a ) and isinstance(a  ,					a ) and isinstance(a  ,					a )
							), 'argument values must be type of "int"'

							if lower > higher:
														raise ValueError("""argument value for lower and higher must be(lower > higher)""" )

							if not lower < to_guess < higher:
														raise ValueError(
														    """guess value must be within the range of lower and higher value""" )

							def answer(a						:	int ) -> str:
														if number > to_guess:
																					return "high"
														elif number < to_guess:
																					return "low"
														else:
																					return "same"

							print("""started...""" )

							snake_case__	  =       lower
							snake_case__	  =       higher

							snake_case__	  =       []

							while True:
														snake_case__	  =       get_avg(a  ,					a )
														last_numbers.append(a )

														if answer(a ) == "low":
																					snake_case__	  =       number
														elif answer(a ) == "high":
																					snake_case__	  =       number
														else:
																					break

							print(F'''guess the number : {last_numbers[-1]}''' )
							print(F'''details : {last_numbers!s}''' )

def _UpperCAmelCase   (	):
							snake_case__	  =       int(input("""Enter lower value : """ ).strip() )
							snake_case__	  =       int(input("""Enter high value : """ ).strip() )
							snake_case__	  =       int(input("""Enter value to guess : """ ).strip() )
							guess_the_number(a  ,					a  ,					a )


if __name__ == "__main__":
	main()








import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class    _lowerCAmelCase			(		lowercase_     ,      lowercase_     ,      unittest.TestCase      ):



				"""simple docstring"""



				_lowercase				:   Optional[int]      =  VQModel
				_lowercase				:   str      =  '''sample'''



				@property
				def 					__magic_name__							(      self    :    Union[str, Any]			,		UpperCamelCase__    :    Tuple=(3_2, 3_2)):






											'''simple docstring'''







											snake_case__	  =       4
											snake_case__	  =       3

											snake_case__	  =       floats_tensor((batch_size, num_channels) + sizes).to(UpperCamelCase__)

											return {"sample": image}



				@property
				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											return (3, 3_2, 3_2)



				@property
				def 					__magic_name__							(      self    :    List[str]):






											'''simple docstring'''







											return (3, 3_2, 3_2)



				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







											snake_case__	  =       {
											    """block_out_channels""": [3_2, 6_4],
											    """in_channels""": 3,
											    """out_channels""": 3,
											    """down_block_types""": ["""DownEncoderBlock2D""", """DownEncoderBlock2D"""],
											    """up_block_types""": ["""UpDecoderBlock2D""", """UpDecoderBlock2D"""],
											    """latent_channels""": 3,
											}
											snake_case__	  =       self.dummy_input
											return init_dict, inputs_dict



				def 					__magic_name__							(      self    :    Optional[int]):






											'''simple docstring'''







											pass



				def 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







											pass



				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											snake_case__  , snake_case__	  =       VQModel.from_pretrained("""fusing/vqgan-dummy"""			,		output_loading_info=UpperCamelCase__)
											self.assertIsNotNone(UpperCamelCase__)
											self.assertEqual(len(loading_info["""missing_keys"""])			,		0)

											model.to(UpperCamelCase__)
											snake_case__	  =       model(**self.dummy_input)

											assert image is not None, "Make sure output is not None"



				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







											snake_case__	  =       VQModel.from_pretrained("""fusing/vqgan-dummy""")
											model.to(UpperCamelCase__).eval()

											torch.manual_seed(0)
											if torch.cuda.is_available():
																		torch.cuda.manual_seed_all(0)

											snake_case__	  =       torch.randn(1			,		model.config.in_channels			,		model.config.sample_size			,		model.config.sample_size)
											snake_case__	  =       image.to(UpperCamelCase__)
											with torch.no_grad():
																		snake_case__	  =       model(UpperCamelCase__).sample

											snake_case__	  =       output[0, -1, -3:, -3:].flatten().cpu()
											# fmt: off
											snake_case__	  =       torch.tensor([-0.01_53, -0.40_44, -0.18_80, -0.51_61, -0.24_18, -0.40_72, -0.16_12, -0.06_33, -0.01_43])
											# fmt: on
											self.assertTrue(torch.allclose(UpperCamelCase__			,		UpperCamelCase__			,		atol=1E-3))
