

'''simple docstring'''






import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 			lowerCAmelCase__     (					lowerCamelCase__				,			unittest.TestCase						):




     """simple docstring"""





     __UpperCamelCase									= UnCLIPImageVariationPipeline
     __UpperCamelCase									= IMAGE_VARIATION_PARAMS - {"height", "width", "guidance_scale"}
     __UpperCamelCase									= IMAGE_VARIATION_BATCH_PARAMS

     __UpperCamelCase									= [
         "generator",
         "return_dict",
         "decoder_num_inference_steps",
         "super_res_num_inference_steps",
     ]
     __UpperCamelCase									= False







     @property
     def 			__lowerCAmelCase	(		self						:	Dict	)       ->			Optional[int]:
          '''simple docstring'''




          return 3_2







     @property
     def 			__lowerCAmelCase	(		self						:	Any	)       ->			List[str]:
          '''simple docstring'''




          return 3_2







     @property
     def 			__lowerCAmelCase	(		self						:	str	)       ->			Dict:
          '''simple docstring'''




          return self.time_input_dim







     @property
     def 			__lowerCAmelCase	(		self						:	Dict	)       ->			Optional[int]:
          '''simple docstring'''




          return self.time_input_dim * 4







     @property
     def 			__lowerCAmelCase	(		self						:	str	)       ->			List[str]:
          '''simple docstring'''




          return 1_0_0







     @property
     def 			__lowerCAmelCase	(		self						:	Tuple	)       ->			List[Any]:
          '''simple docstring'''




          a__   :      List[Any]     =						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)
          return tokenizer







     @property
     def 			__lowerCAmelCase	(		self						:	Optional[Any]	)       ->			Tuple:
          '''simple docstring'''




          torch.manual_seed(0	)
          a__   :      Optional[Any]     =						CLIPTextConfig(
              bos_token_id=0      ,						eos_token_id=2      ,						hidden_size=self.text_embedder_hidden_size      ,						projection_dim=self.text_embedder_hidden_size      ,						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 CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE__	)







     @property
     def 			__lowerCAmelCase	(		self						:	Union[str, Any]	)       ->			Any:
          '''simple docstring'''




          torch.manual_seed(0	)
          a__   :      str     =						CLIPVisionConfig(
              hidden_size=self.text_embedder_hidden_size      ,						projection_dim=self.text_embedder_hidden_size      ,						num_hidden_layers=5      ,						num_attention_heads=4      ,						image_size=3_2      ,						intermediate_size=3_7      ,						patch_size=1      ,						)
          return CLIPVisionModelWithProjection(SCREAMING_SNAKE_CASE__	)







     @property
     def 			__lowerCAmelCase	(		self						:	Any	)       ->			Optional[int]:
          '''simple docstring'''




          torch.manual_seed(0	)

          a__   :      Optional[int]     =						{
              '''clip_embeddings_dim''': self.text_embedder_hidden_size,
              '''time_embed_dim''': self.time_embed_dim,
              '''cross_attention_dim''': self.cross_attention_dim,
          }

          a__   :      Optional[int]     =						UnCLIPTextProjModel(**SCREAMING_SNAKE_CASE__	)
          return model







     @property
     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			Any:
          '''simple docstring'''




          torch.manual_seed(0	)

          a__   :      Tuple     =						{
              '''sample_size''': 3_2,
              # RGB in channels
              '''in_channels''': 3,
              # Out channels is double in channels because predicts mean and variance
              '''out_channels''': 6,
              '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
              '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
              '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
              '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
              '''layers_per_block''': 1,
              '''cross_attention_dim''': self.cross_attention_dim,
              '''attention_head_dim''': 4,
              '''resnet_time_scale_shift''': '''scale_shift''',
              '''class_embed_type''': '''identity''',
          }

          a__   :      List[str]     =						UNetaDConditionModel(**SCREAMING_SNAKE_CASE__	)
          return model







     @property
     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			int:
          '''simple docstring'''




          return {
              "sample_size": 6_4,
              "layers_per_block": 1,
              "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
              "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
              "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
              "in_channels": 6,
              "out_channels": 3,
          }







     @property
     def 			__lowerCAmelCase	(		self						:	Union[str, Any]	)       ->			Optional[Any]:
          '''simple docstring'''




          torch.manual_seed(0	)

          a__   :      Any     =						UNetaDModel(**self.dummy_super_res_kwargs	)
          return model







     @property
     def 			__lowerCAmelCase	(		self						:	Union[str, Any]	)       ->			Optional[Any]:
          '''simple docstring'''




          torch.manual_seed(1	)

          a__   :      int     =						UNetaDModel(**self.dummy_super_res_kwargs	)
          return model







     def 			__lowerCAmelCase	(		self						:	str	)       ->			List[Any]:
          '''simple docstring'''




          a__   :      Optional[Any]     =						self.dummy_decoder
          a__   :      str     =						self.dummy_text_proj
          a__   :      List[Any]     =						self.dummy_text_encoder
          a__   :      Union[str, Any]     =						self.dummy_tokenizer
          a__   :      Optional[Any]     =						self.dummy_super_res_first
          a__   :      str     =						self.dummy_super_res_last

          a__   :      Dict     =						UnCLIPScheduler(
              variance_type='''learned_range'''      ,						prediction_type='''epsilon'''      ,						num_train_timesteps=1_0_0_0      ,						)

          a__   :      Any     =						UnCLIPScheduler(
              variance_type='''fixed_small_log'''      ,						prediction_type='''epsilon'''      ,						num_train_timesteps=1_0_0_0      ,						)

          a__   :      str     =						CLIPImageProcessor(crop_size=3_2      ,						size=3_2	)

          a__   :      Union[str, Any]     =						self.dummy_image_encoder

          return {
              "decoder": decoder,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "text_proj": text_proj,
              "feature_extractor": feature_extractor,
              "image_encoder": image_encoder,
              "super_res_first": super_res_first,
              "super_res_last": super_res_last,
              "decoder_scheduler": decoder_scheduler,
              "super_res_scheduler": super_res_scheduler,
          }







     def 			__lowerCAmelCase	(		self						:	str      ,						A__						:	Union[str, Any]      ,						A__						:	Optional[int]=0      ,						A__						:	Dict=True	)       ->			List[str]:
          '''simple docstring'''




          a__   :      Tuple     =						floats_tensor((1, 3, 3_2, 3_2)      ,						rng=random.Random(SCREAMING_SNAKE_CASE__	)	).to(SCREAMING_SNAKE_CASE__	)
          if str(SCREAMING_SNAKE_CASE__	).startswith('''mps'''	):
               a__   :      int     =						torch.manual_seed(SCREAMING_SNAKE_CASE__	)
          else:
               a__   :      Dict     =						torch.Generator(device=SCREAMING_SNAKE_CASE__	).manual_seed(SCREAMING_SNAKE_CASE__	)

          if pil_image:
               a__   :      Any     =						input_image * 0.5 + 0.5
               a__   :      str     =						input_image.clamp(0      ,						1	)
               a__   :      str     =						input_image.cpu().permute(0      ,						2      ,						3      ,						1	).float().numpy()
               a__   :      Optional[int]     =						DiffusionPipeline.numpy_to_pil(SCREAMING_SNAKE_CASE__	)[0]

          return {
              "image": input_image,
              "generator": generator,
              "decoder_num_inference_steps": 2,
              "super_res_num_inference_steps": 2,
              "output_type": "np",
          }







     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			Optional[int]:
          '''simple docstring'''




          a__   :      Tuple     =						'''cpu'''

          a__   :      Tuple     =						self.get_dummy_components()

          a__   :      Dict     =						self.pipeline_class(**SCREAMING_SNAKE_CASE__	)
          a__   :      Optional[Any]     =						pipe.to(SCREAMING_SNAKE_CASE__	)

          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__	)

          a__   :      Optional[int]     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)

          a__   :      Union[str, Any]     =						pipe(**SCREAMING_SNAKE_CASE__	)
          a__   :      Optional[Any]     =						output.images

          a__   :      Dict     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)

          a__   :      List[str]     =						pipe(
              **SCREAMING_SNAKE_CASE__      ,						return_dict=SCREAMING_SNAKE_CASE__      ,						)[0]

          a__   :      List[str]     =						image[0, -3:, -3:, -1]
          a__   :      Optional[int]     =						image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          a__   :      Union[str, Any]     =						np.array(
              [
                  0.9_997,
                  0.0_002,
                  0.9_997,
                  0.9_997,
                  0.9_969,
                  0.0_023,
                  0.9_997,
                  0.9_969,
                  0.9_970,
              ]	)

          assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1E-2







     def 			__lowerCAmelCase	(		self						:	Tuple	)       ->			Optional[Any]:
          '''simple docstring'''




          a__   :      Dict     =						'''cpu'''

          a__   :      Optional[int]     =						self.get_dummy_components()

          a__   :      Any     =						self.pipeline_class(**SCREAMING_SNAKE_CASE__	)
          a__   :      List[Any]     =						pipe.to(SCREAMING_SNAKE_CASE__	)

          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__	)

          a__   :      str     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)

          a__   :      str     =						pipe(**SCREAMING_SNAKE_CASE__	)
          a__   :      Optional[int]     =						output.images

          a__   :      int     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)

          a__   :      List[Any]     =						pipe(
              **SCREAMING_SNAKE_CASE__      ,						return_dict=SCREAMING_SNAKE_CASE__      ,						)[0]

          a__   :      Optional[int]     =						image[0, -3:, -3:, -1]
          a__   :      List[str]     =						image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          a__   :      int     =						np.array([0.9_997, 0.0_003, 0.9_997, 0.9_997, 0.9_970, 0.0_024, 0.9_997, 0.9_971, 0.9_971]	)

          assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1E-2







     def 			__lowerCAmelCase	(		self						:	Optional[int]	)       ->			Any:
          '''simple docstring'''




          a__   :      int     =						'''cpu'''

          a__   :      Any     =						self.get_dummy_components()

          a__   :      Any     =						self.pipeline_class(**SCREAMING_SNAKE_CASE__	)
          a__   :      int     =						pipe.to(SCREAMING_SNAKE_CASE__	)

          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__	)

          a__   :      Union[str, Any]     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)
          a__   :      Any     =						[
              pipeline_inputs['''image'''],
              pipeline_inputs['''image'''],
          ]

          a__   :      Optional[Any]     =						pipe(**SCREAMING_SNAKE_CASE__	)
          a__   :      Optional[int]     =						output.images

          a__   :      Optional[int]     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)
          a__   :      List[str]     =						[
              tuple_pipeline_inputs['''image'''],
              tuple_pipeline_inputs['''image'''],
          ]

          a__   :      Optional[Any]     =						pipe(
              **SCREAMING_SNAKE_CASE__      ,						return_dict=SCREAMING_SNAKE_CASE__      ,						)[0]

          a__   :      Dict     =						image[0, -3:, -3:, -1]
          a__   :      int     =						image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (2, 6_4, 6_4, 3)

          a__   :      Optional[int]     =						np.array(
              [
                  0.9_997,
                  0.9_989,
                  0.0_008,
                  0.0_021,
                  0.9_960,
                  0.0_018,
                  0.0_014,
                  0.0_002,
                  0.9_933,
              ]	)

          assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1E-2







     def 			__lowerCAmelCase	(		self						:	Optional[Any]	)       ->			Optional[Any]:
          '''simple docstring'''




          a__   :      Tuple     =						torch.device('''cpu'''	)






          class 			lowerCAmelCase__     :




               """simple docstring"""





               __UpperCamelCase									= 1

          a__   :      Union[str, Any]     =						self.get_dummy_components()

          a__   :      Optional[int]     =						self.pipeline_class(**SCREAMING_SNAKE_CASE__	)
          a__   :      Any     =						pipe.to(SCREAMING_SNAKE_CASE__	)

          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__	)

          a__   :      Dict     =						torch.Generator(device=SCREAMING_SNAKE_CASE__	).manual_seed(0	)
          a__   :      Union[str, Any]     =						pipe.decoder.dtype
          a__   :      Union[str, Any]     =						1

          a__   :      Optional[int]     =						(
              batch_size,
              pipe.decoder.config.in_channels,
              pipe.decoder.config.sample_size,
              pipe.decoder.config.sample_size,
          )
          a__   :      Union[str, Any]     =						pipe.prepare_latents(
              SCREAMING_SNAKE_CASE__      ,						dtype=SCREAMING_SNAKE_CASE__      ,						device=SCREAMING_SNAKE_CASE__      ,						generator=SCREAMING_SNAKE_CASE__      ,						latents=SCREAMING_SNAKE_CASE__      ,						scheduler=DummyScheduler()	)

          a__   :      Optional[Any]     =						(
              batch_size,
              pipe.super_res_first.config.in_channels // 2,
              pipe.super_res_first.config.sample_size,
              pipe.super_res_first.config.sample_size,
          )
          a__   :      str     =						pipe.prepare_latents(
              SCREAMING_SNAKE_CASE__      ,						dtype=SCREAMING_SNAKE_CASE__      ,						device=SCREAMING_SNAKE_CASE__      ,						generator=SCREAMING_SNAKE_CASE__      ,						latents=SCREAMING_SNAKE_CASE__      ,						scheduler=DummyScheduler()	)

          a__   :      Any     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)

          a__   :      Optional[Any]     =						pipe(
              **SCREAMING_SNAKE_CASE__      ,						decoder_latents=SCREAMING_SNAKE_CASE__      ,						super_res_latents=SCREAMING_SNAKE_CASE__	).images

          a__   :      Tuple     =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE__      ,						pil_image=SCREAMING_SNAKE_CASE__	)
          # Don't pass image, instead pass embedding
          a__   :      Tuple     =						pipeline_inputs.pop('''image'''	)
          a__   :      Union[str, Any]     =						pipe.image_encoder(SCREAMING_SNAKE_CASE__	).image_embeds

          a__   :      List[str]     =						pipe(
              **SCREAMING_SNAKE_CASE__      ,						decoder_latents=SCREAMING_SNAKE_CASE__      ,						super_res_latents=SCREAMING_SNAKE_CASE__      ,						image_embeddings=SCREAMING_SNAKE_CASE__      ,						).images

          # make sure passing text embeddings manually is identical
          assert np.abs(img_out_a - img_out_a	).max() < 1E-4







     @skip_mps
     def 			__lowerCAmelCase	(		self						:	Union[str, Any]	)       ->			List[str]:
          '''simple docstring'''




          a__   :      Dict     =						torch_device == '''cpu'''

          # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
          a__   :      Any     =						1E-2

          self._test_attention_slicing_forward_pass(
              test_max_difference=SCREAMING_SNAKE_CASE__      ,						expected_max_diff=SCREAMING_SNAKE_CASE__	)







     @skip_mps
     def 			__lowerCAmelCase	(		self						:	Tuple	)       ->			Optional[Any]:
          '''simple docstring'''




          a__   :      List[str]     =						torch_device == '''cpu'''
          a__   :      Optional[int]     =						True
          a__   :      Tuple     =						[
              '''decoder_num_inference_steps''',
              '''super_res_num_inference_steps''',
          ]

          self._test_inference_batch_single_identical(
              test_max_difference=SCREAMING_SNAKE_CASE__      ,						relax_max_difference=SCREAMING_SNAKE_CASE__      ,						additional_params_copy_to_batched_inputs=SCREAMING_SNAKE_CASE__      ,						)







     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			int:
          '''simple docstring'''




          a__   :      Union[str, Any]     =						[
              '''decoder_num_inference_steps''',
              '''super_res_num_inference_steps''',
          ]

          if torch_device == "mps":
               # TODO: MPS errors with larger batch sizes
               a__   :      Optional[Any]     =						[2, 3]
               self._test_inference_batch_consistent(
                   batch_sizes=SCREAMING_SNAKE_CASE__      ,						additional_params_copy_to_batched_inputs=SCREAMING_SNAKE_CASE__      ,						)
          else:
               self._test_inference_batch_consistent(
                   additional_params_copy_to_batched_inputs=SCREAMING_SNAKE_CASE__	)







     @skip_mps
     def 			__lowerCAmelCase	(		self						:	List[str]	)       ->			Dict:
          '''simple docstring'''




          return super().test_dict_tuple_outputs_equivalent()







     @skip_mps
     def 			__lowerCAmelCase	(		self						:	Any	)       ->			Union[str, Any]:
          '''simple docstring'''




          return super().test_save_load_local()







     @skip_mps
     def 			__lowerCAmelCase	(		self						:	Dict	)       ->			Union[str, Any]:
          '''simple docstring'''




          return super().test_save_load_optional_components()






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




     """simple docstring"""





     def 			__lowerCAmelCase	(		self						:	List[str]	)       ->			str:
          '''simple docstring'''




          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







     def 			__lowerCAmelCase	(		self						:	Optional[Any]	)       ->			Optional[int]:
          '''simple docstring'''




          a__   :      Optional[Any]     =						load_image(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''	)
          a__   :      Tuple     =						load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
              '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''	)

          a__   :      Dict     =						UnCLIPImageVariationPipeline.from_pretrained(
              '''kakaobrain/karlo-v1-alpha-image-variations'''      ,						torch_dtype=torch.floataa	)
          a__   :      int     =						pipeline.to(SCREAMING_SNAKE_CASE__	)
          pipeline.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__	)

          a__   :      int     =						torch.Generator(device='''cpu'''	).manual_seed(0	)
          a__   :      Optional[Any]     =						pipeline(
              SCREAMING_SNAKE_CASE__      ,						generator=SCREAMING_SNAKE_CASE__      ,						output_type='''np'''      ,						)

          a__   :      Tuple     =						output.images[0]

          assert image.shape == (2_5_6, 2_5_6, 3)

          assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__      ,						SCREAMING_SNAKE_CASE__      ,						1_5	)




"""simple docstring"""






import unittest

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





def 				A_       ( snake_case__		)					->  Union[str, Any]:
			return x + 2






class      A(  unittest.TestCase		):

		"""simple docstring"""





		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''x = 3'''
					_UpperCamelCase					:List[str]					     =	{}
					_UpperCamelCase					:int					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )

					_UpperCamelCase					:Tuple					     =	'''x = y'''
					_UpperCamelCase					:Optional[int]					     =	{'''y''': 5}
					_UpperCamelCase					:Optional[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 5, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''y = add_two(x)'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )

					# Won't work without the tool
					with CaptureStdout() as out:
								_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result is None
					assert "tried to execute add_two" in out.out
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	'''x = 3'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:List[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
					_UpperCamelCase					:str					     =	{'''x''': 3}
					_UpperCamelCase					:Dict					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	'''x = 3\ny = 5'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''text = f\'This is x: {x}.\''''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == "This is x: 3."
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''text''': '''This is x: 3.'''}   )
		def   _UpperCamelCase( self   )      ->	Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
					_UpperCamelCase					:Dict					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 2}   )

					_UpperCamelCase					:Union[str, Any]					     =	{'''x''': 8}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 8, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	'''test_list = [x, add_two(x)]'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:str					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertListEqual(SCREAMING_SNAKE_CASE__					,				[3, 5]   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	'''y = x'''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 3}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:Tuple					     =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
					_UpperCamelCase					:Optional[Any]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )

					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )





		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''x = 0\nfor i in range(3):\n    x = i'''
					_UpperCamelCase					:Tuple					     =	{}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''range''': range}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 2, '''i''': 2}   )

