



'''simple docstring'''




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   ):


			'''simple docstring'''

			@patch("""sys.argv"""							,					["""fakeprogrampath""", """env"""]						)
			def UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






					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 UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






					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 UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					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 UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






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




'''simple docstring'''




UpperCamelCase__	:     List[Any]    =			10_00


def     lowerCAmelCase_       (     _lowerCamelCase:       float ):
		return x * x


def     lowerCAmelCase_       (     _lowerCamelCase:       Any	,				_lowerCamelCase:       float	,				_lowerCamelCase:       float	,				_lowerCamelCase:       int = 4 ):
		assert callable(
		    _lowerCamelCase ), F"the function(object) passed should be callable your input : {function}"
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"a should be float or integer your input : {a}"
		assert isinstance(function(_lowerCamelCase )	,				(float, int) ), (
		    "the function should return integer or float return type of your function, "
		    F"{type(_lowerCamelCase )}"
		)
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"b should be float or integer your input : {b}"
		assert (
		    isinstance(_lowerCamelCase	,				_lowerCamelCase ) and precision > 0
		), F"precision should be positive integer your input : {precision}"

		# just applying the formula of simpson for approximate integration written in
		# mentioned article in first comment of this file and above this function

		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(b - a) / N_STEPS
		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		function(_lowerCamelCase ) + function(_lowerCamelCase )

		for i in range(1	,				_lowerCamelCase ):
				__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		a + h * i
				result += function(_lowerCamelCase ) * (4 if i % 2 else 2)

		result *= h / 3
		return round(_lowerCamelCase	,				_lowerCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()