





import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


_UpperCAmelCase        =				get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_UpperCAmelCase        =				get_tests_dir('fixtures/vocab.json')
_UpperCAmelCase        =				get_tests_dir('fixtures')



class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Tuple         =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']

       def lowercase (		self: Union[str, Any]		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  0

       def lowercase (		self: Dict		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"		)
              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> Dict:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaConfig()
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"		)

                     # save in new folder
                     model_config.save_pretrained(_SCREAMING_SNAKE_CASE		)
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> Optional[Any]:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     # copy relevant files
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)		)
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.json"		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> str:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaFeatureExtractor()
                     UpperCamelCase_          =  AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"		)

                     UpperCamelCase_          =  WavaVecaProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # save in new folder
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # drop `processor_class` in tokenizer
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "r"		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                            config_dict.pop("processor_class"		)

                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write(json.dumps(_SCREAMING_SNAKE_CASE		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> Any:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaFeatureExtractor()
                     UpperCamelCase_          =  AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"		)

                     UpperCamelCase_          =  WavaVecaProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # save in new folder
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # drop `processor_class` in feature extractor
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "r"		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                            config_dict.pop("processor_class"		)

                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write(json.dumps(_SCREAMING_SNAKE_CASE		)		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Optional[Any]		)       -> List[Any]:




              """simple docstring"""


              with tempfile.TemporaryDirectory() as tmpdirname:
                     UpperCamelCase_          =  WavaVecaConfig(processor_class="Wav2Vec2Processor"		)
                     model_config.save_pretrained(_SCREAMING_SNAKE_CASE		)
                     # copy relevant files
                     copyfile(_SCREAMING_SNAKE_CASE					,   os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.json"		)		)
                     # create emtpy sample processor
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)					,   "w"		) as f:
                            f.write("{}"		)

                     UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Optional[int]		)       -> Dict:




              """simple docstring"""


              with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"		)
              # If remote code is disabled, we can't load this config.
              with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
              self.assertTrue(processor.special_attribute_present		)
              self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)

              UpperCamelCase_          =  processor.feature_extractor
              self.assertTrue(feature_extractor.special_attribute_present		)
              self.assertEqual(feature_extractor.__class__.__name__					,   "NewFeatureExtractor"		)

              UpperCamelCase_          =  processor.tokenizer
              self.assertTrue(tokenizer.special_attribute_present		)
              if is_tokenizers_available():
                     self.assertEqual(tokenizer.__class__.__name__					,   "NewTokenizerFast"		)

                     # Test we can also load the slow version
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE					,   use_fast=_SCREAMING_SNAKE_CASE		)
                     UpperCamelCase_          =  new_processor.tokenizer
                     self.assertTrue(new_tokenizer.special_attribute_present		)
                     self.assertEqual(new_tokenizer.__class__.__name__					,   "NewTokenizer"		)
              else:
                     self.assertEqual(tokenizer.__class__.__name__					,   "NewTokenizer"		)

       def lowercase (		self: Union[str, Any]		)       -> Optional[Any]:




              """simple docstring"""


              try:
                     AutoConfig.register("custom"					,   _SCREAMING_SNAKE_CASE		)
                     AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     AutoTokenizer.register(_SCREAMING_SNAKE_CASE					,   slow_tokenizer_class=_SCREAMING_SNAKE_CASE		)
                     AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     # Trying to register something existing in the Transformers library will raise an error
                     with self.assertRaises(_SCREAMING_SNAKE_CASE		):
                            AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     # Now that the config is registered, it can be used as any other config with the auto-API
                     UpperCamelCase_          =  CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE		)

                     with tempfile.TemporaryDirectory() as tmp_dir:
                            UpperCamelCase_          =  os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.txt"		)
                            with open(_SCREAMING_SNAKE_CASE					,   "w"					,   encoding="utf-8"		) as vocab_writer:
                                   vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
                            UpperCamelCase_          =  CustomTokenizer(_SCREAMING_SNAKE_CASE		)

                     UpperCamelCase_          =  CustomProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                     with tempfile.TemporaryDirectory() as tmp_dir:
                            processor.save_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  AutoProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

              finally:
                     if "custom" in CONFIG_MAPPING._extra_content:
                            del CONFIG_MAPPING._extra_content["custom"]
                     if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                            del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in TOKENIZER_MAPPING._extra_content:
                            del TOKENIZER_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in PROCESSOR_MAPPING._extra_content:
                            del PROCESSOR_MAPPING._extra_content[CustomConfig]

       def lowercase (		self: str		)       -> List[str]:




              """simple docstring"""


              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					List[Any]         =   False



              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					Union[str, Any]         =   False



              class 							_UpperCamelCase					(	lowerCAmelCase_     ):
                     _UpperCamelCase				:					List[str]         =   '''AutoFeatureExtractor'''
                     _UpperCamelCase				:					Dict         =   '''AutoTokenizer'''
                     _UpperCamelCase				:					Optional[Any]         =   False

              try:
                     AutoConfig.register("custom"					,   _SCREAMING_SNAKE_CASE		)
                     AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     AutoTokenizer.register(_SCREAMING_SNAKE_CASE					,   slow_tokenizer_class=_SCREAMING_SNAKE_CASE		)
                     AutoProcessor.register(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
                     # If remote code is not set, the default is to use local classes.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertFalse(processor.special_attribute_present		)
                     self.assertFalse(processor.feature_extractor.special_attribute_present		)
                     self.assertFalse(processor.tokenizer.special_attribute_present		)

                     # If remote code is disabled, we load the local ones.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertFalse(processor.special_attribute_present		)
                     self.assertFalse(processor.feature_extractor.special_attribute_present		)
                     self.assertFalse(processor.tokenizer.special_attribute_present		)

                     # If remote is enabled, we load from the Hub.
                     UpperCamelCase_          =  AutoProcessor.from_pretrained(
                         "hf-internal-testing/test_dynamic_processor"					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
                     self.assertEqual(processor.__class__.__name__					,   "NewProcessor"		)
                     self.assertTrue(processor.special_attribute_present		)
                     self.assertTrue(processor.feature_extractor.special_attribute_present		)
                     self.assertTrue(processor.tokenizer.special_attribute_present		)

              finally:
                     if "custom" in CONFIG_MAPPING._extra_content:
                            del CONFIG_MAPPING._extra_content["custom"]
                     if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                            del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in TOKENIZER_MAPPING._extra_content:
                            del TOKENIZER_MAPPING._extra_content[CustomConfig]
                     if CustomConfig in PROCESSOR_MAPPING._extra_content:
                            del PROCESSOR_MAPPING._extra_content[CustomConfig]

       def lowercase (		self: Any		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-bert"		)
              self.assertEqual(processor.__class__.__name__					,   "BertTokenizerFast"		)



       def lowercase (		self: int		)       -> List[Any]:




              """simple docstring"""


              UpperCamelCase_          =  AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-convnext"		)
              self.assertEqual(processor.__class__.__name__					,   "ConvNextImageProcessor"		)



@is_staging_test
class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Dict         =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']

       @classmethod
       def lowercase (		cls: List[Any]		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  TOKEN
              HfFolder.save_token(_SCREAMING_SNAKE_CASE		)

       @classmethod
       def lowercase (		cls: Tuple		)       -> List[str]:




              """simple docstring"""


              try:
                     delete_repo(token=cls._token					,   repo_id="test-processor"		)
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token					,   repo_id="valid_org/test-processor-org"		)
              except HTTPError:
                     pass

              try:
                     delete_repo(token=cls._token					,   repo_id="test-dynamic-processor"		)
              except HTTPError:
                     pass

       def lowercase (		self: Optional[int]		)       -> Optional[Any]:




              """simple docstring"""


              UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)
              with tempfile.TemporaryDirectory() as tmp_dir:
                     processor.save_pretrained(
                         os.path.join(_SCREAMING_SNAKE_CASE					,   "test-processor"		)					,   push_to_hub=_SCREAMING_SNAKE_CASE					,   use_auth_token=self._token		)

                     UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor'''		)
                     for k, v in processor.feature_extractor.__dict__.items():
                            self.assertEqual(_SCREAMING_SNAKE_CASE					,   getattr(new_processor.feature_extractor					,   _SCREAMING_SNAKE_CASE		)		)
                     self.assertDictEqual(new_processor.tokenizer.get_vocab()					,   processor.tokenizer.get_vocab()		)

       def lowercase (		self: str		)       -> Optional[Any]:




              """simple docstring"""


              UpperCamelCase_          =  WavaVecaProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     processor.save_pretrained(
                         os.path.join(_SCREAMING_SNAKE_CASE					,   "test-processor-org"		)					,   push_to_hub=_SCREAMING_SNAKE_CASE					,   use_auth_token=self._token					,   organization="valid_org"					,   )

                     UpperCamelCase_          =  WavaVecaProcessor.from_pretrained("valid_org/test-processor-org"		)
                     for k, v in processor.feature_extractor.__dict__.items():
                            self.assertEqual(_SCREAMING_SNAKE_CASE					,   getattr(new_processor.feature_extractor					,   _SCREAMING_SNAKE_CASE		)		)
                     self.assertDictEqual(new_processor.tokenizer.get_vocab()					,   processor.tokenizer.get_vocab()		)



       def lowercase (		self: List[Any]		)       -> List[str]:




              """simple docstring"""


              CustomFeatureExtractor.register_for_auto_class()
              CustomTokenizer.register_for_auto_class()
              CustomProcessor.register_for_auto_class()

              UpperCamelCase_          =  CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     UpperCamelCase_          =  os.path.join(_SCREAMING_SNAKE_CASE					,   "vocab.txt"		)
                     with open(_SCREAMING_SNAKE_CASE					,   "w"					,   encoding="utf-8"		) as vocab_writer:
                            vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
                     UpperCamelCase_          =  CustomTokenizer(_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  CustomProcessor(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

              with tempfile.TemporaryDirectory() as tmp_dir:
                     create_repo(f'''{USER}/test-dynamic-processor'''					,   token=self._token		)
                     UpperCamelCase_          =  Repository(_SCREAMING_SNAKE_CASE					,   clone_from=f'''{USER}/test-dynamic-processor'''					,   token=self._token		)
                     processor.save_pretrained(_SCREAMING_SNAKE_CASE		)

                     # This has added the proper auto_map field to the feature extractor config
                     self.assertDictEqual(
                         processor.feature_extractor.auto_map					,   {
                             "AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor",
                             "AutoProcessor": "custom_processing.CustomProcessor",
                         }					,   )

                     # This has added the proper auto_map field to the tokenizer config
                     with open(os.path.join(_SCREAMING_SNAKE_CASE					,   "tokenizer_config.json"		)		) as f:
                            UpperCamelCase_          =  json.load(_SCREAMING_SNAKE_CASE		)
                     self.assertDictEqual(
                         tokenizer_config["auto_map"]					,   {
                             "AutoTokenizer": ["custom_tokenization.CustomTokenizer", None],
                             "AutoProcessor": "custom_processing.CustomProcessor",
                         }					,   )

                     # The code has been copied from fixtures
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_feature_extraction.py"		)		)		)
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_tokenization.py"		)		)		)
                     self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE					,   "custom_processing.py"		)		)		)

                     repo.push_to_hub()

              UpperCamelCase_          =  AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor'''					,   trust_remote_code=_SCREAMING_SNAKE_CASE		)
              # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
              self.assertEqual(new_processor.__class__.__name__					,   "CustomProcessor"		)








import unittest

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




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Optional[int]:
       return x + 2







class 							_UpperCamelCase					(	unittest.TestCase     ):

       def lowercase (		self: Optional[int]		)       -> str:




              """simple docstring"""


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

              UpperCamelCase_          =  "x = y"
              UpperCamelCase_          =  {"y": 5}
              UpperCamelCase_          =  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 lowercase (		self: List[str]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  "y = add_two(x)"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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_          =  evaluate(_SCREAMING_SNAKE_CASE					,   {}					,   state=_SCREAMING_SNAKE_CASE		)
              assert result is None
              assert "tried to execute add_two" in out.out

       def lowercase (		self: Union[str, Any]		)       -> str:




              """simple docstring"""


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

       def lowercase (		self: Dict		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  "test_dict = {'x': x, 'y': add_two(x)}"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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 lowercase (		self: List[str]		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  "x = 3\ny = 5"
              UpperCamelCase_          =  {}
              UpperCamelCase_          =  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 lowercase (		self: List[Any]		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  "text = f'This is x: {x}.'"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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 lowercase (		self: int		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  "if x <= 3:\n    y = 2\nelse:\n    y = 5"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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_          =  {"x": 8}
              UpperCamelCase_          =  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 lowercase (		self: str		)       -> Optional[Any]:




              """simple docstring"""


              UpperCamelCase_          =  "test_list = [x, add_two(x)]"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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 lowercase (		self: List[str]		)       -> int:




              """simple docstring"""


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

       def lowercase (		self: str		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  "test_list = [x, add_two(x)]\ntest_list[1]"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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_          =  "test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']"
              UpperCamelCase_          =  {"x": 3}
              UpperCamelCase_          =  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 lowercase (		self: Dict		)       -> Optional[int]:




              """simple docstring"""


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

