




"""simple docstring"""







import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()




class       lowerCAmelCase__       (			unittest.TestCase    ):


				"""simple docstring"""





				@property
				def       snake_case    (     self					:	Optional[Any]						):
						torch.manual_seed(0						)
						__lowercase				:		Optional[Any]												=				UNetaDModel(
						    block_out_channels=(3_2, 6_4)    ,   layers_per_block=2    ,   sample_size=3_2    ,   in_channels=3    ,   out_channels=3    ,   down_block_types=("DownBlock2D", "AttnDownBlock2D")    ,   up_block_types=("AttnUpBlock2D", "UpBlock2D")    ,   )
						return model



				@property
				def       snake_case    (     self					:	Any						):
						torch.manual_seed(0						)
						__lowercase				:		Any												=				VQModel(
						    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    ,   )
						return model



				@property
				def       snake_case    (     self					:	Optional[int]						):
						torch.manual_seed(0						)
						__lowercase				:		Optional[Any]												=				CLIPTextConfig(
						    bos_token_id=0    ,   eos_token_id=2    ,   hidden_size=3_2    ,   intermediate_size=3_7    ,   layer_norm_eps=1e-05    ,   num_attention_heads=4    ,   num_hidden_layers=5    ,   pad_token_id=1    ,   vocab_size=1_0_0_0    ,   )
						return CLIPTextModel(__UpperCamelCase						)



				def       snake_case    (     self					:	List[str]						):
						__lowercase				:		int												=				self.dummy_uncond_unet
						__lowercase				:		List[str]												=				DDIMScheduler()
						__lowercase				:		str												=				self.dummy_vq_model

						__lowercase				:		List[Any]												=				LDMPipeline(unet=__UpperCamelCase    ,   vqvae=__UpperCamelCase    ,   scheduler=__UpperCamelCase						)
						ldm.to(__UpperCamelCase						)
						ldm.set_progress_bar_config(disable=__UpperCamelCase						)

						__lowercase				:		List[Any]												=				torch.manual_seed(0						)
						__lowercase				:		int												=				ldm(generator=__UpperCamelCase    ,   num_inference_steps=2    ,   output_type="numpy"						).images

						__lowercase				:		List[Any]												=				torch.manual_seed(0						)
						__lowercase				:		Optional[int]												=				ldm(generator=__UpperCamelCase    ,   num_inference_steps=2    ,   output_type="numpy"    ,   return_dict=__UpperCamelCase						)[0]

						__lowercase				:		List[str]												=				image[0, -3:, -3:, -1]
						__lowercase				:		Dict												=				image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)
						__lowercase				:		Union[str, Any]												=				np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2]						)
						__lowercase				:		str												=				1e-2 if torch_device != "mps" else 3e-2

						assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < tolerance





@slow
@require_torch
class       lowerCAmelCase__       (			unittest.TestCase    ):


				"""simple docstring"""





				def       snake_case    (     self					:	Tuple						):
						__lowercase				:		Optional[int]												=				LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256"						)
						ldm.to(__UpperCamelCase						)
						ldm.set_progress_bar_config(disable=__UpperCamelCase						)

						__lowercase				:		Tuple												=				torch.manual_seed(0						)
						__lowercase				:		Dict												=				ldm(generator=__UpperCamelCase    ,   num_inference_steps=5    ,   output_type="numpy"						).images

						__lowercase				:		List[str]												=				image[0, -3:, -3:, -1]

						assert image.shape == (1, 2_5_6, 2_5_6, 3)
						__lowercase				:		Union[str, Any]												=				np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7]						)
						__lowercase				:		List[Any]												=				1e-2 if torch_device != "mps" else 3e-2

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






"""simple docstring"""







import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate

def 						snake_case__       (					_lowerCamelCase				)			->Dict:






		"""simple docstring"""


		return x + 2





class       lowerCAmelCase__       (			unittest.TestCase    ):


				"""simple docstring"""





				def       snake_case    (     self					:	List[str]						):
						__lowercase				:		List[Any]												=				"x = 3"
						__lowercase				:		Optional[int]												=				{}
						__lowercase				:		List[Any]												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						assert result == 3
						self.assertDictEqual(lowercase__    ,   {"x": 3}						)

						__lowercase				:		Optional[int]												=				"x = y"
						__lowercase				:		Union[str, Any]												=				{"y": 5}
						__lowercase				:		str												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						# evaluate returns the value of the last assignment.
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 5, "y": 5}						)



				def       snake_case    (     self					:	Dict						):
						__lowercase				:		Dict												=				"y = add_two(x)"
						__lowercase				:		List[Any]												=				{"x": 3}
						__lowercase				:		Optional[int]												=				evaluate(lowercase__    ,   {"add_two": add_two}    ,   state=lowercase__						)
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 3, "y": 5}						)

						# Won't work without the tool
						with CaptureStdout() as out:
								__lowercase				:		Any												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						assert result is None
						assert "tried to execute add_two" in out.out



				def       snake_case    (     self					:	Any						):
						__lowercase				:		Optional[Any]												=				"x = 3"
						__lowercase				:		List[Any]												=				{}
						__lowercase				:		Dict												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						assert result == 3
						self.assertDictEqual(lowercase__    ,   {"x": 3}						)



				def       snake_case    (     self					:	str						):
						__lowercase				:		Optional[int]												=				"test_dict = {'x': x, 'y': add_two(x)}"
						__lowercase				:		List[str]												=				{"x": 3}
						__lowercase				:		Tuple												=				evaluate(lowercase__    ,   {"add_two": add_two}    ,   state=lowercase__						)
						self.assertDictEqual(lowercase__    ,   {"x": 3, "y": 5}						)
						self.assertDictEqual(lowercase__    ,   {"x": 3, "test_dict": {"x": 3, "y": 5}}						)



				def       snake_case    (     self					:	int						):
						__lowercase				:		Tuple												=				"x = 3\ny = 5"
						__lowercase				:		Optional[Any]												=				{}
						__lowercase				:		List[Any]												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						# evaluate returns the value of the last assignment.
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 3, "y": 5}						)



				def       snake_case    (     self					:	Any						):
						__lowercase				:		str												=				"text = f'This is x: {x}.'"
						__lowercase				:		Any												=				{"x": 3}
						__lowercase				:		List[Any]												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						# evaluate returns the value of the last assignment.
						assert result == "This is x: 3."
						self.assertDictEqual(lowercase__    ,   {"x": 3, "text": "This is x: 3."}						)



				def       snake_case    (     self					:	str						):
						__lowercase				:		Optional[Any]												=				"if x <= 3:\n    y = 2\nelse:\n    y = 5"
						__lowercase				:		int												=				{"x": 3}
						__lowercase				:		Optional[int]												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						# evaluate returns the value of the last assignment.
						assert result == 2
						self.assertDictEqual(lowercase__    ,   {"x": 3, "y": 2}						)

						__lowercase				:		Optional[int]												=				{"x": 8}
						__lowercase				:		Union[str, Any]												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						# evaluate returns the value of the last assignment.
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 8, "y": 5}						)



				def       snake_case    (     self					:	Dict						):
						__lowercase				:		Optional[Any]												=				"test_list = [x, add_two(x)]"
						__lowercase				:		str												=				{"x": 3}
						__lowercase				:		Any												=				evaluate(lowercase__    ,   {"add_two": add_two}    ,   state=lowercase__						)
						self.assertListEqual(lowercase__    ,   [3, 5]						)
						self.assertDictEqual(lowercase__    ,   {"x": 3, "test_list": [3, 5]}						)



				def       snake_case    (     self					:	Optional[int]						):
						__lowercase				:		str												=				"y = x"
						__lowercase				:		str												=				{"x": 3}
						__lowercase				:		int												=				evaluate(lowercase__    ,   {}    ,   state=lowercase__						)
						assert result == 3
						self.assertDictEqual(lowercase__    ,   {"x": 3, "y": 3}						)



				def       snake_case    (     self					:	Optional[int]						):
						__lowercase				:		str												=				"test_list = [x, add_two(x)]\ntest_list[1]"
						__lowercase				:		Optional[Any]												=				{"x": 3}
						__lowercase				:		Any												=				evaluate(lowercase__    ,   {"add_two": add_two}    ,   state=lowercase__						)
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 3, "test_list": [3, 5]}						)

						__lowercase				:		Tuple												=				"test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']"
						__lowercase				:		Union[str, Any]												=				{"x": 3}
						__lowercase				:		Tuple												=				evaluate(lowercase__    ,   {"add_two": add_two}    ,   state=lowercase__						)
						assert result == 5
						self.assertDictEqual(lowercase__    ,   {"x": 3, "test_dict": {"x": 3, "y": 5}}						)



				def       snake_case    (     self					:	Dict						):
						__lowercase				:		Dict												=				"x = 0\nfor i in range(3):\n    x = i"
						__lowercase				:		str												=				{}
						__lowercase				:		int												=				evaluate(lowercase__    ,   {"range": range}    ,   state=lowercase__						)
						assert result == 2
						self.assertDictEqual(lowercase__    ,   {"x": 2, "i": 2}						)
