
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       A__  (		unittest.TestCase							):





							@patch('sys.argv'	,					['fakeprogrampath', 'env']							)
							def      a__					(					self    :  Union[str, Any]							)		->						List[str]:



											"""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      a__					(					self    :  Any							)		->						List[Any]:



											"""simple docstring"""


											import transformers.commands.transformers_cli

											shutil.rmtree('/tmp/hf-internal-testing/tiny-random-gptj'	,					ignore_errors=_UpperCAmelCase							)  # 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    :  int							)		->						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=_UpperCAmelCase							)

											# 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    :  Optional[int]							)		->						List[str]:



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

											# 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'							)							)







from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
							from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore
class       A__  (		lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				c_float





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



											"""simple docstring"""


											return sizeof(self.value							)






def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: int       ,				SCREAMING_SNAKE_CASE			: int       ,				SCREAMING_SNAKE_CASE			: int = 0     )	->		int:
				# < 0 is possible if using a dynamic axis
				if dimension <= 0:
								__lowercase								=   fixed_dimension

				dimension -= num_token_to_add
				return dimension




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: int       ,				SCREAMING_SNAKE_CASE			: ParameterFormat     )	->		int:
				return num_parameters * dtype.size




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: str     )	->		Optional[Union["AutoTokenizer", "AutoFeatureExtractor", "AutoProcessor"]]:
				from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

				try:
								return AutoProcessor.from_pretrained(SCREAMING_SNAKE_CASE     )
				except (ValueError, OSError, KeyError):
								__lowercase						,   __lowercase								=   None, None
								try:
												__lowercase								=   AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE     )
								except (OSError, KeyError):
												pass
								try:
												__lowercase								=   AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE     )
								except (OSError, KeyError):
												pass

								if tokenizer is not None and feature_extractor is not None:
												raise ValueError(
												    F"""Couldn't auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor."""     )
								elif tokenizer is None and feature_extractor is None:
												return None
								elif tokenizer is not None:
												return tokenizer
								else:
												return feature_extractor





