


"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCamelCase__				:str			   =	{
    """configuration_ctrl""": ["""CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CTRLConfig"""],
    """tokenization_ctrl""": ["""CTRLTokenizer"""],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__				:Dict			   =	[
					    """CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """CTRLForSequenceClassification""",
					    """CTRLLMHeadModel""",
					    """CTRLModel""",
					    """CTRLPreTrainedModel""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__				:List[str]			   =	[
					    """TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFCTRLForSequenceClassification""",
					    """TFCTRLLMHeadModel""",
					    """TFCTRLModel""",
					    """TFCTRLPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
					from .tokenization_ctrl import CTRLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ctrl import (
										    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CTRLForSequenceClassification,
										    CTRLLMHeadModel,
										    CTRLModel,
										    CTRLPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ctrl import (
										    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCTRLForSequenceClassification,
										    TFCTRLLMHeadModel,
										    TFCTRLModel,
										    TFCTRLPreTrainedModel,
										)

else:
					import sys

					UpperCamelCase__				:Union[str, Any]			   =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





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

