





import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow
class 			UpperCamelCase_		:




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Dict:
										return None





class 			UpperCamelCase_		:




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Any:
										return None





class 			UpperCamelCase_		(  unittest.TestCase					):
					lowerCAmelCase_							=	[
					    # (model_name, model_kwargs)
					    ('''bert-base-cased''', {}),
					    ('''gpt2''', {'''use_cache''': False}),  # We don't support exporting GPT2 past keys anymore
					]




					@require_tf
					@slow
					def 	lowerCAmelCase			(		self  )		->							int:
										for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
															self._test_export(lowerCAmelCase_				,						'tf'				,						12				,						**lowerCAmelCase_  )




					@require_torch
					@slow
					def 	lowerCAmelCase			(		self  )		->							int:
										for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
															self._test_export(lowerCAmelCase_				,						'pt'				,						12				,						**lowerCAmelCase_  )




					@require_torch
					@slow
					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										from transformers import BertModel

										_snake_case									=				['[UNK]', '[SEP]', '[CLS]', '[PAD]', '[MASK]', 'some', 'other', 'words']
										with NamedTemporaryFile(mode='w+t'  ) as vocab_file:
															vocab_file.write('\n'.join(lowerCAmelCase_  )  )
															vocab_file.flush()
															_snake_case									=				BertTokenizerFast(vocab_file.name  )

										with TemporaryDirectory() as bert_save_dir:
															_snake_case									=				BertModel(BertConfig(vocab_size=len(lowerCAmelCase_  )  )  )
															model.save_pretrained(lowerCAmelCase_  )
															self._test_export(lowerCAmelCase_				,						'pt'				,						12				,						lowerCAmelCase_  )




					@require_tf
					@slow
					def 	lowerCAmelCase			(		self  )		->							List[str]:
										for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
															_snake_case									=				self._test_export(lowerCAmelCase_				,						'tf'				,						12				,						**lowerCAmelCase_  )
															_snake_case									=				quantize(Path(lowerCAmelCase_  )  )

															# Ensure the actual quantized model is not bigger than the original one
															if quantized_path.stat().st_size >= Path(lowerCAmelCase_  ).stat().st_size:
																				self.fail('Quantized model is bigger than initial ONNX model'  )




					@require_torch
					@slow
					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
															_snake_case									=				self._test_export(lowerCAmelCase_				,						'pt'				,						12				,						**lowerCAmelCase_  )
															_snake_case									=				quantize(lowerCAmelCase_  )

															# Ensure the actual quantized model is not bigger than the original one
															if quantized_path.stat().st_size >= Path(lowerCAmelCase_  ).stat().st_size:
																				self.fail('Quantized model is bigger than initial ONNX model'  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_=None				,						**lowerCAmelCase_  )		->							Tuple:
										try:
															# Compute path
															with TemporaryDirectory() as tempdir:
																				_snake_case									=				Path(lowerCAmelCase_  ).joinpath('model.onnx'  )

															# Remove folder if exists
															if path.parent.exists():
																				path.parent.rmdir()

															# Export
															convert(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						**lowerCAmelCase_  )

															return path
										except Exception as e:
															self.fail(lowerCAmelCase_  )




					@require_torch
					@require_tokenizers
					@slow
					def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										from transformers import BertModel

										_snake_case									=				BertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'  )  )
										_snake_case									=				BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'  )
										self._test_infer_dynamic_axis(lowerCAmelCase_				,						lowerCAmelCase_				,						'pt'  )




					@require_tf
					@require_tokenizers
					@slow
					def 	lowerCAmelCase			(		self  )		->							Dict:
										from transformers import TFBertModel

										_snake_case									=				TFBertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'  )  )
										_snake_case									=				BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'  )
										self._test_infer_dynamic_axis(lowerCAmelCase_				,						lowerCAmelCase_				,						'tf'  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							int:
										_snake_case									=				FeatureExtractionPipeline(lowerCAmelCase_				,						lowerCAmelCase_  )

										_snake_case									=				['input_ids', 'token_type_ids', 'attention_mask', 'output_0', 'output_1']
										_snake_case							,     _snake_case							,     _snake_case							,     _snake_case									=				infer_shapes(lowerCAmelCase_				,						lowerCAmelCase_  )

										# Assert all variables are present
										self.assertEqual(len(lowerCAmelCase_  )				,						len(lowerCAmelCase_  )  )
										self.assertTrue(all(var_name in shapes for var_name in variable_names  )  )
										self.assertSequenceEqual(variable_names[:3]				,						lowerCAmelCase_  )
										self.assertSequenceEqual(variable_names[3:]				,						lowerCAmelCase_  )

										# Assert inputs are {0: batch, 1: sequence}
										for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
															self.assertDictEqual(shapes[var_name]				,						{0: 'batch', 1: 'sequence'}  )

										# Assert outputs are {0: batch, 1: sequence} and {0: batch}
										self.assertDictEqual(shapes['output_0']				,						{0: 'batch', 1: 'sequence'}  )
										self.assertDictEqual(shapes['output_1']				,						{0: 'batch'}  )




					def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										_snake_case									=				['input_ids', 'attention_mask', 'token_type_ids']
										_snake_case									=				{'input_ids': [1, 2, 3, 4], 'attention_mask': [0, 0, 0, 0], 'token_type_ids': [1, 1, 1, 1]}
										_snake_case							,     _snake_case									=				ensure_valid_input(FuncContiguousArgs()				,						lowerCAmelCase_				,						lowerCAmelCase_  )

										# Should have exactly the same number of args (all are valid)
										self.assertEqual(len(lowerCAmelCase_  )				,						3  )

										# Should have exactly the same input names
										self.assertEqual(set(lowerCAmelCase_  )				,						set(lowerCAmelCase_  )  )

										# Parameter should be reordered according to their respective place in the function:
										# (input_ids, token_type_ids, attention_mask)
										self.assertEqual(lowerCAmelCase_				,						(tokens['input_ids'], tokens['token_type_ids'], tokens['attention_mask'])  )

										# Generated args are interleaved with another args (for instance parameter "past" in GPT2)
										_snake_case							,     _snake_case									=				ensure_valid_input(FuncNonContiguousArgs()				,						lowerCAmelCase_				,						lowerCAmelCase_  )

										# Should have exactly the one arg (all before the one not provided "some_other_args")
										self.assertEqual(len(lowerCAmelCase_  )				,						1  )
										self.assertEqual(len(lowerCAmelCase_  )				,						1  )

										# Should have only "input_ids"
										self.assertEqual(inputs_args[0]				,						tokens['input_ids']  )
										self.assertEqual(ordered_input_names[0]				,						'input_ids'  )






					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				generate_identified_filename(Path('/home/something/my_fake_model.onnx'  )				,						'-test'  )
										self.assertEqual('/home/something/my_fake_model-test.onnx'				,						generated.as_posix()  )










import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test
class 			UpperCamelCase_		(  unittest.TestCase					):




					@parameterized.expand([(None,), ('foo.json',)]  )
					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_  )		->							str:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						bad_words_ids=[[1, 2, 3], [4, 5]]				,						)
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowerCAmelCase_				,						config_name=lowerCAmelCase_  )
															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_				,						config_name=lowerCAmelCase_  )

										# Checks parameters that were specified
										self.assertEqual(loaded_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(loaded_config.temperature				,						0.7  )
										self.assertEqual(loaded_config.length_penalty				,						1.0  )
										self.assertEqual(loaded_config.bad_words_ids				,						[[1, 2, 3], [4, 5]]  )

										# Checks parameters that were not specified (defaults)
										self.assertEqual(loaded_config.top_k				,						50  )
										self.assertEqual(loaded_config.max_length				,						20  )
										self.assertEqual(loaded_config.max_time				,						lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				AutoConfig.from_pretrained('gpt2'  )
										_snake_case									=				GenerationConfig.from_model_config(lowerCAmelCase_  )
										_snake_case									=				GenerationConfig()

										# The generation config has loaded a few non-default parameters from the model config
										self.assertNotEqual(lowerCAmelCase_				,						lowerCAmelCase_  )

										# One of those parameters is eos_token_id -- check if it matches
										self.assertNotEqual(generation_config_from_model.eos_token_id				,						default_generation_config.eos_token_id  )
										self.assertEqual(generation_config_from_model.eos_token_id				,						model_config.eos_token_id  )




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case									=				GenerationConfig()
										_snake_case									=				{
										    'max_new_tokens': 1024,
										    'foo': 'bar',
										}
										_snake_case									=				copy.deepcopy(lowerCAmelCase_  )
										_snake_case									=				generation_config.update(**lowerCAmelCase_  )

										# update_kwargs was not modified (no side effects)
										self.assertEqual(lowerCAmelCase_				,						lowerCAmelCase_  )

										# update_kwargs was used to update the config on valid attributes
										self.assertEqual(generation_config.max_new_tokens				,						1024  )

										# `.update()` returns a dictionary of unused kwargs
										self.assertEqual(lowerCAmelCase_				,						{'foo': 'bar'}  )




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				GenerationConfig()
										_snake_case									=				'bar'

										with tempfile.TemporaryDirectory('test-generation-config'  ) as tmp_dir:
															generation_config.save_pretrained(lowerCAmelCase_  )

															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_  )
										# update_kwargs was used to update the config on valid attributes
										self.assertEqual(new_config.foo				,						'bar'  )

										_snake_case									=				GenerationConfig.from_model_config(lowerCAmelCase_  )
										assert not hasattr(lowerCAmelCase_				,						'foo'  )  # no new kwargs should be initialized if from config






					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										_snake_case									=				GenerationConfig()
										self.assertEqual(default_config.temperature				,						1.0  )
										self.assertEqual(default_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(default_config.num_beams				,						1  )

										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						bad_words_ids=[[1, 2, 3], [4, 5]]				,						)
										self.assertEqual(config.temperature				,						0.7  )
										self.assertEqual(config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(config.num_beams				,						1  )

										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowerCAmelCase_  )
															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_				,						temperature=1.0  )

										self.assertEqual(loaded_config.temperature				,						1.0  )
										self.assertEqual(loaded_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(loaded_config.num_beams				,						1  )  # default value





@is_staging_test
class 			UpperCamelCase_		(  unittest.TestCase					):




					@classmethod
					def 	lowerCAmelCase			(		cls  )		->							List[str]:
										_snake_case									=				TOKEN
										HfFolder.save_token(lowerCAmelCase_  )




					@classmethod
					def 	lowerCAmelCase			(		cls  )		->							Union[str, Any]:
										try:
															delete_repo(token=cls._token				,						repo_id='test-generation-config'  )
										except HTTPError:
															pass

										try:
															delete_repo(token=cls._token				,						repo_id='valid_org/test-generation-config-org'  )
										except HTTPError:
															pass




					def 	lowerCAmelCase			(		self  )		->							int:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						)
										config.push_to_hub('test-generation-config'				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )

        # Reset repo
										delete_repo(token=self._token				,						repo_id='test-generation-config'  )

										# Push to hub via save_pretrained
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(
															    lowerCAmelCase_				,						repo_id='test-generation-config'				,						push_to_hub=lowerCAmelCase_				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )






					def 	lowerCAmelCase			(		self  )		->							List[str]:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						)
										config.push_to_hub('valid_org/test-generation-config-org'				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained('valid_org/test-generation-config-org'  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )

        # Reset repo
										delete_repo(token=self._token				,						repo_id='valid_org/test-generation-config-org'  )

										# Push to hub via save_pretrained
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(
															    lowerCAmelCase_				,						repo_id='valid_org/test-generation-config-org'				,						push_to_hub=lowerCAmelCase_				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained('valid_org/test-generation-config-org'  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )



