






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import MaskFormerSwinBackbone
  from transformers.models.maskformer import MaskFormerSwinModel


class       __lowercase      :







     '''simple docstring'''




     def __init__(				self       :			Any ,	UpperCamelCase_       :			Any ,	UpperCamelCase_       :			Any=13 ,	UpperCamelCase_       :			Optional[Any]=32 ,	UpperCamelCase_       :			Union[str, Any]=2 ,	UpperCamelCase_       :			Optional[int]=3 ,	UpperCamelCase_       :			List[str]=16 ,	UpperCamelCase_       :			Tuple=[1, 2, 1] ,	UpperCamelCase_       :			List[Any]=[2, 2, 4] ,	UpperCamelCase_       :			Union[str, Any]=2 ,	UpperCamelCase_       :			Optional[Any]=2.0 ,	UpperCamelCase_       :			Tuple=True ,	UpperCamelCase_       :			Optional[Any]=0.0 ,	UpperCamelCase_       :			Dict=0.0 ,	UpperCamelCase_       :			int=0.1 ,	UpperCamelCase_       :			str="gelu" ,	UpperCamelCase_       :			int=False ,	UpperCamelCase_       :			int=True ,	UpperCamelCase_       :			Tuple=0.02 ,	UpperCamelCase_       :			Tuple=1e-5 ,	UpperCamelCase_       :			Optional[Any]=True ,	UpperCamelCase_       :			List[str]=None ,	UpperCamelCase_       :			List[str]=True ,	UpperCamelCase_       :			int=10 ,	UpperCamelCase_       :			Optional[int]=8 ,	UpperCamelCase_       :			Tuple=["stage1", "stage2", "stage3"] ,	UpperCamelCase_       :			int=[1, 2, 3] ,	):


         """simple docstring"""



         __A         =	parent
         __A         =	batch_size
         __A         =	image_size
         __A         =	patch_size
         __A         =	num_channels
         __A         =	embed_dim
         __A         =	depths
         __A         =	num_heads
         __A         =	window_size
         __A         =	mlp_ratio
         __A         =	qkv_bias
         __A         =	hidden_dropout_prob
         __A         =	attention_probs_dropout_prob
         __A         =	drop_path_rate
         __A         =	hidden_act
         __A         =	use_absolute_embeddings
         __A         =	patch_norm
         __A         =	layer_norm_eps
         __A         =	initializer_range
         __A         =	is_training
         __A         =	scope
         __A         =	use_labels
         __A         =	type_sequence_label_size
         __A         =	encoder_stride
         __A         =	out_features
         __A         =	out_indices




     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         __A         =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

         __A         =	None
         if self.use_labels:
             __A         =	ids_tensor([self.batch_size] ,	self.type_sequence_label_size				)

         __A         =	self.get_config()

         return config, pixel_values, labels




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         return MaskFormerSwinConfig(
             image_size=self.image_size ,	patch_size=self.patch_size ,	num_channels=self.num_channels ,	embed_dim=self.embed_dim ,	depths=self.depths ,	num_heads=self.num_heads ,	window_size=self.window_size ,	mlp_ratio=self.mlp_ratio ,	qkv_bias=self.qkv_bias ,	hidden_dropout_prob=self.hidden_dropout_prob ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob ,	drop_path_rate=self.drop_path_rate ,	hidden_act=self.hidden_act ,	use_absolute_embeddings=self.use_absolute_embeddings ,	path_norm=self.patch_norm ,	layer_norm_eps=self.layer_norm_eps ,	initializer_range=self.initializer_range ,	encoder_stride=self.encoder_stride ,	out_features=self.out_features ,	out_indices=self.out_indices ,	)




     def 		lowerCAmelCase_     (				self       :			List[Any] ,	UpperCamelCase_       :			Optional[int] ,	UpperCamelCase_       :			List[str] ,	UpperCamelCase_       :			List[str]				):


         """simple docstring"""



         __A         =	MaskFormerSwinModel(config=UpperCamelCase_				)
         model.to(UpperCamelCase_				)
         model.eval()
         __A         =	model(UpperCamelCase_				)

         __A         =	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
         __A         =	int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

         self.parent.assertEqual(result.last_hidden_state.shape ,	(self.batch_size, expected_seq_len, expected_dim)				)




     def 		lowerCAmelCase_     (				self       :			Optional[Any] ,	UpperCamelCase_       :			Optional[Any] ,	UpperCamelCase_       :			List[str] ,	UpperCamelCase_       :			Any				):


         """simple docstring"""



         __A         =	MaskFormerSwinBackbone(config=UpperCamelCase_				)
         model.to(UpperCamelCase_				)
         model.eval()
         __A         =	model(UpperCamelCase_				)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps				) ,	len(config.out_features				)				)
         self.parent.assertListEqual(list(result.feature_maps[0].shape				) ,	[13, 16, 16, 16]				)

         # verify channels
         self.parent.assertEqual(len(model.channels				) ,	len(config.out_features				)				)
         self.parent.assertListEqual(model.channels ,	[16, 32, 64]				)

         # verify ValueError
         with self.parent.assertRaises(UpperCamelCase_				):
             __A         =	["""stem"""]
             __A         =	MaskFormerSwinBackbone(config=UpperCamelCase_				)





     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	self.prepare_config_and_inputs()
         __A    ,	__A    ,	__A         =	config_and_inputs
         __A         =	{"""pixel_values""": pixel_values}
         return config, inputs_dict


@require_torch
class       __lowercase      (	lowercase_			,      lowercase_			,      unittest.TestCase  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				(
         (
             MaskFormerSwinModel,
             MaskFormerSwinBackbone,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE   						=				{"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False




     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	MaskFormerSwinModelTester(self				)
         __A         =	ConfigTester(self ,	config_class=UpperCamelCase_ ,	embed_dim=37				)




     @require_torch_multi_gpu
     @unittest.skip(
         reason=(
             """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"""
             """ `nn.DataParallel`"""
         )				)
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()




     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         return




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*UpperCamelCase_				)




     @unittest.skip("""Swin does not use inputs_embeds"""				)
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         pass




     @unittest.skip("""Swin does not support feedforward chunking"""				)
     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __A         =	model_class(UpperCamelCase_				)
             self.assertIsInstance(model.get_input_embeddings() ,	(nn.Module)				)
             __A         =	model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(UpperCamelCase_ ,	nn.Linear				)				)




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __A         =	model_class(UpperCamelCase_				)
             __A         =	inspect.signature(model.forward				)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             __A         =	[*signature.parameters.keys()]

             __A         =	["""pixel_values"""]
             self.assertListEqual(arg_names[:1] ,	UpperCamelCase_				)




     @unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""				)
     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         pass




     @unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""				)
     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			List[str] ,	UpperCamelCase_       :			List[Any] ,	UpperCamelCase_       :			Any ,	UpperCamelCase_       :			Tuple ,	UpperCamelCase_       :			Tuple				):


         """simple docstring"""



         __A         =	model_class(UpperCamelCase_				)
         model.to(UpperCamelCase_				)
         model.eval()

         with torch.no_grad():
             __A         =	model(**self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)				)

         __A         =	outputs.hidden_states

         __A         =	getattr(
             self.model_tester ,	"""expected_num_hidden_layers""" ,	len(self.model_tester.depths				) + 1				)
         self.assertEqual(len(UpperCamelCase_				) ,	UpperCamelCase_				)

         # Swin has a different seq_length
         __A         =	(
             config.patch_size
             if isinstance(config.patch_size ,	collections.abc.Iterable				)
             else (config.patch_size, config.patch_size)
         )

         __A         =	(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]				) ,	[num_patches, self.model_tester.embed_dim] ,	)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

         __A         =	(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size ,	collections.abc.Iterable				)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes:
             __A         =	True
             self.check_hidden_states_output(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_				)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __A         =	True

             self.check_hidden_states_output(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()
         __A         =	3

         __A         =	(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size ,	collections.abc.Iterable				)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         __A         =	(
             config.patch_size
             if isinstance(config.patch_size ,	collections.abc.Iterable				)
             else (config.patch_size, config.patch_size)
         )

         __A         =	image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         __A         =	image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
             __A         =	True
             self.check_hidden_states_output(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	(padded_height, padded_width)				)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __A         =	True
             self.check_hidden_states_output(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	(padded_height, padded_width)				)




     @unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""				)
     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         pass




     @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""				)
     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         pass




     @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""				)
     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         pass





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

         def set_nan_tensor_to_zero(UpperCamelCase_       :			str				):
             __A         =	0
             return t

         def check_equivalence(UpperCamelCase_       :			str ,	UpperCamelCase_       :			Optional[int] ,	UpperCamelCase_       :			Optional[Any] ,	UpperCamelCase_       :			int={}				):
             with torch.no_grad():
                 __A         =	model(**UpperCamelCase_ ,	return_dict=UpperCamelCase_ ,	**UpperCamelCase_				)
                 __A         =	model(**UpperCamelCase_ ,	return_dict=UpperCamelCase_ ,	**UpperCamelCase_				).to_tuple()

                 def recursive_check(UpperCamelCase_       :			Any ,	UpperCamelCase_       :			List[str]				):
                     if isinstance(UpperCamelCase_ ,	(List, Tuple)				):
                         for tuple_iterable_value, dict_iterable_value in zip(UpperCamelCase_ ,	UpperCamelCase_				):
                             recursive_check(UpperCamelCase_ ,	UpperCamelCase_				)
                     elif isinstance(UpperCamelCase_ ,	UpperCamelCase_				):
                         for tuple_iterable_value, dict_iterable_value in zip(
                             tuple_object.values() ,	dict_object.values()				):
                             recursive_check(UpperCamelCase_ ,	UpperCamelCase_				)
                     elif tuple_object is None:
                         return
                     else:
                         self.assertTrue(
                             torch.allclose(
                                 set_nan_tensor_to_zero(UpperCamelCase_				) ,	set_nan_tensor_to_zero(UpperCamelCase_				) ,	atol=1e-5				) ,	msg=(
                                 """Tuple and dict output are not equal. Difference:"""
                                 F" {torch.max(torch.abs(tuple_object - dict_object				)				)}. Tuple has `nan`:"
                                 F" {torch.isnan(UpperCamelCase_				).any()} and `inf`: {torch.isinf(UpperCamelCase_				)}. Dict has"
                                 F" `nan`: {torch.isnan(UpperCamelCase_				).any()} and `inf`: {torch.isinf(UpperCamelCase_				)}."
                             ) ,	)

                 recursive_check(UpperCamelCase_ ,	UpperCamelCase_				)

         for model_class in self.all_model_classes:
             __A         =	model_class(UpperCamelCase_				)
             model.to(UpperCamelCase_				)
             model.eval()

             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)
             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)
             check_equivalence(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_				)

             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_ ,	return_labels=UpperCamelCase_				)
             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_ ,	return_labels=UpperCamelCase_				)
             check_equivalence(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_				)

             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)
             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)
             check_equivalence(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	{"""output_hidden_states""": True}				)

             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_ ,	return_labels=UpperCamelCase_				)
             __A         =	self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_ ,	return_labels=UpperCamelCase_				)
             check_equivalence(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_ ,	{"""output_hidden_states""": True}				)


@require_torch
class       __lowercase      (	unittest.TestCase			,      lowercase_  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				(MaskFormerSwinBackbone,) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE   						=				MaskFormerSwinConfig




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         __A         =	MaskFormerSwinModelTester(self				)





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()
         __A         =	inputs_dict["""pixel_values"""].shape[0]

         for backbone_class in self.all_model_classes:
             __A         =	backbone_class(UpperCamelCase_				)
             backbone.to(UpperCamelCase_				)
             backbone.eval()

             __A         =	backbone(**UpperCamelCase_				)

             # Test default outputs and verify feature maps
             self.assertIsInstance(outputs.feature_maps ,	UpperCamelCase_				)
             self.assertTrue(len(outputs.feature_maps				) == len(backbone.channels				)				)
             for feature_map, n_channels in zip(outputs.feature_maps ,	backbone.channels				):
                 self.assertTrue(feature_map.shape[:2] ,	(batch_size, n_channels)				)
             self.assertIsNone(outputs.hidden_states				)
             self.assertIsNone(outputs.attentions				)

             # Test output_hidden_states=True
             __A         =	backbone(**UpperCamelCase_ ,	output_hidden_states=UpperCamelCase_				)
             self.assertIsNotNone(outputs.hidden_states				)
             self.assertTrue(len(outputs.hidden_states				) ,	len(backbone.stage_names				)				)
             # We skip the stem layer
             for hidden_states, n_channels in zip(outputs.hidden_states[1:] ,	backbone.channels				):
                 for hidden_state in hidden_states:
                     # Hidden states are in the format (batch_size, (height * width), n_channels)
                     __A    ,	__A    ,	__A         =	hidden_state.shape
                     self.assertTrue((h_batch_size, h_n_channels) ,	(batch_size, n_channels)				)

            # Test output_attentions=True
             if self.has_attentions:
                 __A         =	backbone(**UpperCamelCase_ ,	output_attentions=UpperCamelCase_				)
                 self.assertIsNotNone(outputs.attentions				)












import unittest

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



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Optional[int]    )						->      List[str]:





    """simple docstring"""

    return x + 2






class       __lowercase      (	unittest.TestCase  ):







     '''simple docstring'''




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""x = 3"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3}				)

         __A         =	"""x = y"""
         __A         =	{"""y""": 5}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 5, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""y = add_two(x)"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)

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




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	"""x = 3"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3}				)




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	"""test_dict = {'x': x, 'y': add_two(x)}"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}				)




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	"""x = 3\ny = 5"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"""text = f'This is x: {x}.'"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == "This is x: 3."
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """text""": """This is x: 3."""}				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	"""if x <= 3:\n    y = 2\nelse:\n    y = 5"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 2
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 2}				)

         __A         =	{"""x""": 8}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 8, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"""test_list = [x, add_two(x)]"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         self.assertListEqual(UpperCamelCase_ ,	[3, 5]				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_list""": [3, 5]}				)




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A         =	"""y = x"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 3}				)




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""test_list = [x, add_two(x)]\ntest_list[1]"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_list""": [3, 5]}				)

         __A         =	"""test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}				)





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	"""x = 0\nfor i in range(3):\n    x = i"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{"""range""": range} ,	state=UpperCamelCase_				)
         assert result == 2
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 2, """i""": 2}				)




