




import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
 from transformers.pipelines.conversational import Conversation


lowerCamelCase							:						Optional[int]					       =  logging.get_logger(__name__)

lowerCamelCase							:						Union[str, Any]					       =  {"vocab_file": "vocab.txt", "emoji_file": "emoji.json"}

lowerCamelCase							:						Tuple					       =  {
    "vocab_file": {
        "abeja/gpt-neox-japanese-2.7b": "https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt",
    },
    "emoji_file": {
        "abeja/gpt-neox-japanese-2.7b": "https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json",
    },
}

lowerCamelCase							:						Any					       =  {
    "abeja/gpt-neox-japanese-2.7b": 2_048,
}

def      _SCREAMING_SNAKE_CASE     (				lowercase      :			Tuple      ,				lowercase      :			Any	):


      '''simple docstring'''



      with open(lowercase      ,				'r'      ,				encoding='utf-8'	) as f:
            lowerCamelCase_							=       json.loads(f.read()	)

      lowerCamelCase_							=       collections.OrderedDict()
      lowerCamelCase_							=       collections.OrderedDict()
      lowerCamelCase_							=       collections.OrderedDict()
      with open(lowercase      ,				'r'      ,				encoding='utf-8'	) as f:
            lowerCamelCase_							=       f.readlines()
      lowerCamelCase_							=       [[t.rstrip('\n'	)] if (t == ',' or ',' not in t) else t.rstrip('\n'	).split(','	) for t in token]
      for idx, b in enumerate(lowercase	):
            lowerCamelCase_							=       b
            lowerCamelCase_							=       idx
            for wd in b:
                  lowerCamelCase_							=       idx

      return vocab, raw_vocab, ids_to_tokens, emoji







class     A(		UpperCamelCase  ):



 '''simple docstring'''


 UpperCamelCase		  =		VOCAB_FILES_NAMES
 UpperCamelCase		  =		PRETRAINED_VOCAB_FILES_MAP
 UpperCamelCase		  =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 UpperCamelCase		  =		['''input_ids''', '''attention_mask''']

 def __init__(							self   :    str		,				A_   :    Any		,				A_   :    Any		,				A_   :    Optional[Any]="<|endoftext|>"		,				A_   :    Any="<|endoftext|>"		,				A_   :    Optional[int]="<|startoftext|>"		,				A_   :    Union[str, Any]="<|endoftext|>"		,				A_   :    Any=False		,				**A_   :    Tuple		,				)  ->      Dict:

       """simple docstring"""






       super().__init__(
           unk_token=A_		,				pad_token=A_		,				bos_token=A_		,				eos_token=A_		,				do_clean_text=A_		,				**A_		,				)
       if not os.path.isfile(A_    ):
             raise ValueError(
                 f"""Can't find a vocabulary file at path '{vocab_file}'. To load the vocabulary from a Google pretrained"""
                 ' model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'    )
       if not os.path.isfile(A_    ):
             raise ValueError(
                 f"""Can't find a emoji file at path '{emoji_file}'. To load the emoji information from a Google"""
                 ' pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'    )
       lowerCamelCase_							=       do_clean_text
       lowerCamelCase_	,							lowerCamelCase_	,							lowerCamelCase_	,							lowerCamelCase_							=       load_vocab_and_emoji(A_		,				A_    )
       lowerCamelCase_							=       SubWordJapaneseTokenizer(
           vocab=self.vocab		,				ids_to_tokens=self.ids_to_tokens		,				emoji=self.emoji    )

 @property
 def 							a__					(							self   :    List[str]    )  ->      Dict:

       """simple docstring"""






       return len(self.raw_vocab    )

 def 							a__					(							self   :    Tuple    )  ->      Optional[Any]:

       """simple docstring"""






       return dict(self.raw_vocab		,				**self.added_tokens_encoder    )

 def 							a__					(							self   :    Optional[Any]		,				A_   :    str    )  ->      Tuple:

       """simple docstring"""






       return self.subword_tokenizer.tokenize(A_		,				clean=self.do_clean_text    )

 def 							a__					(							self   :    Optional[int]		,				A_   :    Dict    )  ->      List[Any]:

       """simple docstring"""






       return self.vocab.get(A_		,				self.vocab.get(self.unk_token    )    )

 def 							a__					(							self   :    Union[str, Any]		,				A_   :    Union[str, Any]    )  ->      int:

       """simple docstring"""






       return self.subword_tokenizer.convert_id_to_token(A_    )

 def 							a__					(							self   :    Optional[int]		,				A_   :    Optional[int]    )  ->      int:

       """simple docstring"""






       lowerCamelCase_							=       ''.join(A_    ).strip()
       return out_string

 def 							a__					(							self   :    Optional[Any]		,				A_   :    "Conversation"    )  ->      List[int]:

       """simple docstring"""






       lowerCamelCase_							=       []
       for is_user, text in conversation.iter_texts():
             input_ids.extend(self.encode(A_		,				add_special_tokens=A_    ) + [self.eos_token_id]    )

       if len(A_    ) > self.model_max_length:
             lowerCamelCase_							=       input_ids[-self.model_max_length :]
       return input_ids





 def 							a__					(							self   :    List[Any]		,				A_   :    str		,				A_   :    Optional[str] = None    )  ->      Tuple[str]:

       """simple docstring"""






       lowerCamelCase_							=       0
       if os.path.isdir(A_    ):
             lowerCamelCase_							=       os.path.join(
                 A_		,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']    )
             lowerCamelCase_							=       os.path.join(
                 A_		,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['emoji_file']    )
       else:
             lowerCamelCase_							=       (
                 (filename_prefix + '-' if filename_prefix else '') + save_directory + VOCAB_FILES_NAMES['vocab_file']
             )
             lowerCamelCase_							=       (
                 (filename_prefix + '-' if filename_prefix else '') + save_directory + VOCAB_FILES_NAMES['emoji_file']
             )
       with open(A_		,				'w'		,				encoding='utf-8'    ) as writer:
             for token_index, token in self.ids_to_tokens.items():
                   if index != token_index:
                         logger.warning(
                             f"""Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."""
                             ' Please check that the vocabulary is not corrupted!'    )
                         lowerCamelCase_							=       token_index
                   writer.write(','.join(A_    ) + '\n'    )
                   index += 1
       with open(A_		,				'w'		,				encoding='utf-8'    ) as writer:
             json.dump(self.emoji		,				A_    )
       return vocab_file, emoji_file







class     A(		UpperCamelCase  ):



 '''simple docstring'''


 def __init__(							self   :    Any		,				A_   :    Union[str, Any]		,				A_   :    int		,				A_   :    Tuple    )  ->      Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=       vocab  # same as swe
       lowerCamelCase_							=       ids_to_tokens  # same as bpe
       lowerCamelCase_							=       emoji
       lowerCamelCase_							=       np.max([len(A_    ) for w in self.vocab.keys()]    )
       lowerCamelCase_							=       re.compile(r'(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)'    )
       lowerCamelCase_							=       re.compile(r'[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*'    )
       lowerCamelCase_							=       re.compile(r'[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}'    )
       lowerCamelCase_							=       re.compile(
           r'([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'    )
       lowerCamelCase_							=       re.compile(
           r'(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'    )
       lowerCamelCase_							=       re.compile(
           r'((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*'    )
       lowerCamelCase_							=       '─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿'
       lowerCamelCase_							=       '▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟'
       lowerCamelCase_							=       str.maketrans({k: '<BLOCK>' for k in keisen + blocks}    )

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

       """simple docstring"""






       return len(self.ids_to_tokens    )

 def 							a__					(							self   :    Union[str, Any]		,				A_   :    Dict    )  ->      Optional[Any]:

       """simple docstring"""






       lowerCamelCase_							=       self.content_repattera.sub('<URL>'		,				A_    )
       lowerCamelCase_							=       self.content_repattera.sub('<EMAIL>'		,				A_    )
       lowerCamelCase_							=       self.content_repattera.sub('<TEL>'		,				A_    )
       lowerCamelCase_							=       self.content_repattera.sub('<DATE>'		,				A_    )
       lowerCamelCase_							=       self.content_repattera.sub('<DATE>'		,				A_    )
       lowerCamelCase_							=       self.content_repattera.sub('<PRICE>'		,				A_    )
       lowerCamelCase_							=       content.translate(self.content_transa    )
       while "<BLOCK><BLOCK>" in content:
             lowerCamelCase_							=       content.replace('<BLOCK><BLOCK>'		,				'<BLOCK>'    )
       return content

 def 							a__					(							self   :    int		,				A_   :    Optional[Any]		,				A_   :    Tuple=False    )  ->      Dict:

       """simple docstring"""






       lowerCamelCase_							=       text.replace(' '		,				'<SP>'    )
       lowerCamelCase_							=       text.replace('　'		,				'<SP>'    )
       lowerCamelCase_							=       text.replace('\r\n'		,				'<BR>'    )
       lowerCamelCase_							=       text.replace('\n'		,				'<BR>'    )
       lowerCamelCase_							=       text.replace('\r'		,				'<BR>'    )
       lowerCamelCase_							=       text.replace('\t'		,				'<TAB>'    )
       lowerCamelCase_							=       text.replace('—'		,				'ー'    )
       lowerCamelCase_							=       text.replace('−'		,				'ー'    )
       for k, v in self.emoji["emoji"].items():
             if k in text:
                   lowerCamelCase_							=       text.replace(A_		,				A_    )
       if clean:
             lowerCamelCase_							=       self.clean_text(A_    )

       def check_simbol(A_   :    Union[str, Any]    ):
             lowerCamelCase_							=       x.encode()
             if len(A_    ) == 1 and len(A_    ) == 2:
                   lowerCamelCase_							=       (int(e[0]    ) << 8) + int(e[1]    )
                   if (
                       (c >= 0XC2_A1 and c <= 0XC2_BF)
                       or (c >= 0XC7_80 and c <= 0XC7_83)
                       or (c >= 0XCA_B9 and c <= 0XCB_BF)
                       or (c >= 0XCC_80 and c <= 0XCD_A2)
                   ):
                         return True
             return False

       def checkuae(A_   :    Tuple    ):
             lowerCamelCase_							=       x.encode()
             if len(A_    ) == 1 and len(A_    ) == 3:
                   lowerCamelCase_							=       (int(e[0]    ) << 16) + (int(e[1]    ) << 8) + int(e[2]    )
                   if c >= 0XE2_80_80 and c <= 0XE2_B0_7F:
                         return True
             return False

       lowerCamelCase_							=       0
       lowerCamelCase_							=       []
       while pos < len(A_    ):
             lowerCamelCase_							=       min(len(A_    )		,				pos + self.maxlen + 1    ) if text[pos] == '<' else pos + 3
             lowerCamelCase_							=       []  # (token_id, token, pos)
             for e in range(A_		,				A_		,				-1    ):
                   lowerCamelCase_							=       text[pos:e]
                   if wd in self.vocab:
                         if wd[0] == "<" and len(A_    ) > 2:
                               lowerCamelCase_							=       [(self.vocab[wd], wd, e)]
                               break
                         else:
                               candidates.append((self.vocab[wd], wd, e)    )
             if len(A_    ) > 0:
                   # the smallest token_id is adopted
                   lowerCamelCase_	,							lowerCamelCase_	,							lowerCamelCase_							=       sorted(A_		,				key=lambda A_    : x[0]    )[0]
                   result.append(A_    )
                   lowerCamelCase_							=       e
             else:
                   lowerCamelCase_							=       pos + 1
                   lowerCamelCase_							=       text[pos:end]
                   if check_simbol(A_    ):
                         result.append('<KIGOU>'    )
                   elif checkuae(A_    ):
                         result.append('<U2000U2BFF>'    )
                   else:
                         for i in wd.encode('utf-8'    ):
                               result.append('<|byte%d|>' % i    )
                   lowerCamelCase_							=       end
       return result





 def 							a__					(							self   :    List[Any]		,				A_   :    Tuple		,				A_   :    List[str]="\n"    )  ->      List[str]:

       """simple docstring"""






       lowerCamelCase_							=       []
       lowerCamelCase_							=       []
       lowerCamelCase_							=       self.ids_to_tokens[index][0]
       if word[:6] == "<|byte" and word[-2:] == "|>":
             byte_tokens.append(int(word[6:-2]    )    )
       else:
             if len(A_    ) > 0:
                   words.append(bytearray(A_    ).decode('utf-8'		,				errors='replace'    )    )
                   lowerCamelCase_							=       []
             if word[:7] == "<|emoji" and word[-2:] == "|>":
                   words.append(self.emoji['emoji_inv'][word]    )
             elif word == "<SP>":
                   words.append(' '    )
             elif word == "<BR>":
                   words.append(A_    )
             elif word == "<TAB>":
                   words.append('\t'    )
             elif word == "<BLOCK>":
                   words.append('▀'    )
             elif word == "<KIGOU>":
                   words.append('ǀ'    )
             elif word == "<U2000U2BFF>":
                   words.append('‖'    )
             else:
                   words.append(A_    )
       if len(A_    ) > 0:
             words.append(bytearray(A_    ).decode('utf-8'		,				errors='replace'    )    )
       lowerCamelCase_							=       ''.join(A_    )
       return text







"""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}   )

