



'''simple docstring'''





import json
import os
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from requests.exceptions import HTTPError

from transformers.utils import (
    CONFIG_NAME,
    FLAX_WEIGHTS_NAME,
    TF2_WEIGHTS_NAME,
    TRANSFORMERS_CACHE,
    WEIGHTS_NAME,
    cached_file,
    get_file_from_repo,
    has_file,
)


a_						:     int	     =		'hf-internal-testing/tiny-random-bert'
a_						:     Union[str, Any]	     =		os.path.join(TRANSFORMERS_CACHE, 'models--hf-internal-testing--tiny-random-bert')
a_						:     List[str]	     =		'9b8c223d42b2188cb49d29af482996f9d0f3e5a6'





class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		cached_file(UpperCamelCase_				,			UpperCamelCase_    )
           # Should have downloaded the file in here
           self.assertTrue(os.path.isdir(UpperCamelCase_    )    )
           # Cache should contain at least those three subfolders:
           for subfolder in ["blobs", "refs", "snapshots"]:
                 self.assertTrue(os.path.isdir(os.path.join(UpperCamelCase_				,			UpperCamelCase_    )    )    )
           with open(os.path.join(UpperCamelCase_				,			"refs"				,			"main"    )    ) as f:
                 lowerCamelCase								=		f.read()
           self.assertEqual(UpperCamelCase_				,			os.path.join(UpperCamelCase_				,			"snapshots"				,			UpperCamelCase_				,			UpperCamelCase_    )    )
           self.assertTrue(os.path.isfile(UpperCamelCase_    )    )

           # File is cached at the same place the second time.
           lowerCamelCase								=		cached_file(UpperCamelCase_				,			UpperCamelCase_    )
           self.assertEqual(UpperCamelCase_				,			UpperCamelCase_    )

           # Using a specific revision to test the full commit hash.
           lowerCamelCase								=		cached_file(UpperCamelCase_				,			UpperCamelCase_				,			revision="9b8c223"    )
           self.assertEqual(UpperCamelCase_				,			os.path.join(UpperCamelCase_				,			"snapshots"				,			UpperCamelCase_				,			UpperCamelCase_    )    )







     def 						_a      (self    ):






           '''simple docstring'''



           with self.assertRaisesRegex(UpperCamelCase_				,			"is not a valid model identifier"    ):
                 lowerCamelCase								=		cached_file("tiny-random-bert"				,			UpperCamelCase_    )

           with self.assertRaisesRegex(UpperCamelCase_				,			"is not a valid git identifier"    ):
                 lowerCamelCase								=		cached_file(UpperCamelCase_				,			UpperCamelCase_				,			revision="aaaa"    )

           with self.assertRaisesRegex(UpperCamelCase_				,			"does not appear to have a file named"    ):
                 lowerCamelCase								=		cached_file(UpperCamelCase_				,			"conf"    )







     def 						_a      (self    ):






           '''simple docstring'''



           with self.assertRaisesRegex(UpperCamelCase_				,			"does not appear to have a file named"    ):
                 lowerCamelCase								=		cached_file(UpperCamelCase_				,			"conf"    )

           with open(os.path.join(UpperCamelCase_				,			"refs"				,			"main"    )    ) as f:
                 lowerCamelCase								=		f.read()
           self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase_				,			".no_exist"				,			UpperCamelCase_				,			"conf"    )    )    )

           lowerCamelCase								=		cached_file(UpperCamelCase_				,			"conf"				,			_raise_exceptions_for_missing_entries=UpperCamelCase_    )
           self.assertIsNone(UpperCamelCase_    )

           lowerCamelCase								=		cached_file(UpperCamelCase_				,			"conf"				,			local_files_only=UpperCamelCase_				,			_raise_exceptions_for_missing_entries=UpperCamelCase_    )
           self.assertIsNone(UpperCamelCase_    )

           lowerCamelCase								=		mock.Mock()
           lowerCamelCase								=		5_00
           lowerCamelCase								=		{}
           lowerCamelCase								=		HTTPError
           lowerCamelCase								=		{}

           # Under the mock environment we get a 500 error when trying to reach the tokenizer.
           with mock.patch("requests.Session.request"				,			return_value=UpperCamelCase_    ) as mock_head:
                 lowerCamelCase								=		cached_file(UpperCamelCase_				,			"conf"				,			_raise_exceptions_for_connection_errors=UpperCamelCase_    )
                 self.assertIsNone(UpperCamelCase_    )
                 # This check we did call the fake head request
                 mock_head.assert_called()







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertTrue(has_file("hf-internal-testing/tiny-bert-pt-only"				,			UpperCamelCase_    )    )
           self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"				,			UpperCamelCase_    )    )
           self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"				,			UpperCamelCase_    )    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertIsNone(get_file_from_repo("bert-base-cased"				,			"ahah.txt"    )    )

           # The function raises if the repository does not exist.
           with self.assertRaisesRegex(UpperCamelCase_				,			"is not a valid model identifier"    ):
                 get_file_from_repo("bert-base-case"				,			UpperCamelCase_    )

           # The function raises if the revision does not exist.
           with self.assertRaisesRegex(UpperCamelCase_				,			"is not a valid git identifier"    ):
                 get_file_from_repo("bert-base-cased"				,			UpperCamelCase_				,			revision="ahaha"    )

           lowerCamelCase								=		get_file_from_repo("bert-base-cased"				,			UpperCamelCase_    )
           # The name is the cached name which is not very easy to test, so instead we load the content.
           lowerCamelCase								=		json.loads(open(UpperCamelCase_				,			"r"    ).read()    )
           self.assertEqual(config["hidden_size"]				,			7_68    )







     def 						_a      (self    ):






           '''simple docstring'''



           with tempfile.TemporaryDirectory() as tmp_dir:
                 lowerCamelCase								=		Path(UpperCamelCase_    ) / "a.txt"
                 filename.touch()
                 self.assertEqual(get_file_from_repo(UpperCamelCase_				,			"a.txt"    )				,			str(UpperCamelCase_    )    )

                 self.assertIsNone(get_file_from_repo(UpperCamelCase_				,			"b.txt"    )    )




import unittest

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

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      return x + 2






class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     def 						_a      (self    ):






           '''simple docstring'''



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

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







     def 						_a      (self    ):






           '''simple docstring'''



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

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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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

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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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







     def 						_a      (self    ):






           '''simple docstring'''



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

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







     def 						_a      (self    ):






           '''simple docstring'''



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