
import os
import shutil
import unittest
from unittest.mock import patch

from transformers.testing_utils import CaptureStd, is_pt_tf_cross_test, require_torch
class    _UpperCamelCase(   unittest.TestCase				):

						@patch("sys.argv"	,						["fakeprogrampath", "env"]			)
						def 						a__ (					self		:			List[Any]			):
													# test transformers-cli env
													import transformers.commands.transformers_cli

													with CaptureStd() as cs:
																				transformers.commands.transformers_cli.main()
													self.assertIn("Python version"	,						cs.out			)
													self.assertIn("Platform"	,						cs.out			)
													self.assertIn("Using distributed or parallel set-up in script?"	,						cs.out			)

						@is_pt_tf_cross_test
						@patch(
						    "sys.argv"	,						["fakeprogrampath", "pt-to-tf", "--model-name", "hf-internal-testing/tiny-random-gptj", "--no-pr"]			)
						def 						a__ (					self		:			Any			):
													import transformers.commands.transformers_cli

													shutil.rmtree("/tmp/hf-internal-testing/tiny-random-gptj"	,						ignore_errors=_lowerCamelCase			)  # cleans potential past runs
													transformers.commands.transformers_cli.main()

													# The original repo has no TF weights -- if they exist, they were created by the CLI
													self.assertTrue(os.path.exists("/tmp/hf-internal-testing/tiny-random-gptj/tf_model.h5"			)			)

						@require_torch
						@patch("sys.argv"	,						["fakeprogrampath", "download", "hf-internal-testing/tiny-random-gptj", "--cache-dir", "/tmp"]			)
						def 						a__ (					self		:			List[Any]			):
													import transformers.commands.transformers_cli

													# # remove any previously downloaded model to start clean
													shutil.rmtree("/tmp/models--hf-internal-testing--tiny-random-gptj"	,						ignore_errors=_lowerCamelCase			)

													# run the command
													transformers.commands.transformers_cli.main()

													# check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--tiny-random-gptj
													self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/blobs"			)			)
													self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/refs"			)			)
													self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/snapshots"			)			)






						@require_torch
						@patch(
						    "sys.argv"	,						[
						        "fakeprogrampath",
						        "download",
						        "hf-internal-testing/test_dynamic_model_with_tokenizer",
						        "--trust-remote-code",
						        "--cache-dir",
						        "/tmp",
						    ]	,						)
						def 						a__ (					self		:			List[str]			):
													import transformers.commands.transformers_cli

													# # remove any previously downloaded model to start clean
													shutil.rmtree("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer"	,						ignore_errors=_lowerCamelCase			)

													# run the command
													transformers.commands.transformers_cli.main()

													# check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer
													self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/blobs"			)			)
													self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/refs"			)			)
													self.assertTrue(
													    os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/snapshots"			)			)






def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )   ->      Dict:

							"""simple docstring"""






							if power < 0:
														return -1
							base %= mod
							_UpperCAmelCase  :			Optional[Any]	       =		1

							while power > 0:
														if power & 1:
																					_UpperCAmelCase  :			Optional[Any]	       =		(result * base) % mod
														_UpperCAmelCase  :			List[str]	       =		power >> 1
														_UpperCAmelCase  :			Optional[int]	       =		(base * base) % mod

							return result




def 		lowerCAmelCase_     (     )   ->      List[str]:

							"""simple docstring"""






							print(modular_exponential(3      ,	2_0_0      ,	1_3  )  )


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				main()




