




'''simple docstring'''







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





     '''simple docstring'''



     def 			snake_case_      (				self							,__a							,__a							,__a							)      ->				Any:
          return None







class 					_a :





     '''simple docstring'''



     def 			snake_case_      (				self							,__a							,__a							,__a							,__a							)      ->				str:
          return None







class 					_a (unittest.TestCase	):





     '''simple docstring'''



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







     @require_tf
     @slow
     def 			snake_case_      (				self							)      ->				List[Any]:
          for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               self._test_export(__a							,"""tf"""							,12							,**__a							)







     @require_torch
     @slow
     def 			snake_case_      (				self							)      ->				List[str]:
          for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               self._test_export(__a							,"""pt"""							,12							,**__a							)







     @require_torch
     @slow
     def 			snake_case_      (				self							)      ->				Optional[int]:
          from transformers import BertModel

          snake_case			:      List[Any]        =			["""[UNK]""", """[SEP]""", """[CLS]""", """[PAD]""", """[MASK]""", """some""", """other""", """words"""]
          with NamedTemporaryFile(mode="""w+t"""							) as vocab_file:
               vocab_file.write("""\n""".join(__a							)							)
               vocab_file.flush()
               snake_case			:      Any        =			BertTokenizerFast(vocab_file.name							)

          with TemporaryDirectory() as bert_save_dir:
               snake_case			:      Union[str, Any]        =			BertModel(BertConfig(vocab_size=len(__a							)							)							)
               model.save_pretrained(__a							)
               self._test_export(__a							,"""pt"""							,12							,__a							)







     @require_tf
     @slow
     def 			snake_case_      (				self							)      ->				Tuple:
          for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               snake_case			:      Union[str, Any]        =			self._test_export(__a							,"""tf"""							,12							,**__a							)
               snake_case			:      List[Any]        =			quantize(Path(__a							)							)

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







     @require_torch
     @slow
     def 			snake_case_      (				self							)      ->				Optional[int]:
          for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               snake_case			:      Union[str, Any]        =			self._test_export(__a							,"""pt"""							,12							,**__a							)
               snake_case			:      Any        =			quantize(__a							)

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







     def 			snake_case_      (				self							,__a							,__a							,__a							,__a=None							,**__a							)      ->				Any:
          try:
               # Compute path
               with TemporaryDirectory() as tempdir:
                    snake_case			:      List[Any]        =			Path(__a							).joinpath("""model.onnx"""							)

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

               # Export
               convert(__a							,__a							,__a							,__a							,__a							,**__a							)

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







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

          snake_case			:      List[str]        =			BertModel(BertConfig.from_pretrained("""lysandre/tiny-bert-random"""							)							)
          snake_case			:      List[str]        =			BertTokenizerFast.from_pretrained("""lysandre/tiny-bert-random"""							)
          self._test_infer_dynamic_axis(__a							,__a							,"""pt"""							)







     @require_tf
     @require_tokenizers
     @slow
     def 			snake_case_      (				self							)      ->				Any:
          from transformers import TFBertModel

          snake_case			:      int        =			TFBertModel(BertConfig.from_pretrained("""lysandre/tiny-bert-random"""							)							)
          snake_case			:      str        =			BertTokenizerFast.from_pretrained("""lysandre/tiny-bert-random"""							)
          self._test_infer_dynamic_axis(__a							,__a							,"""tf"""							)







     def 			snake_case_      (				self							,__a							,__a							,__a							)      ->				Optional[Any]:
          snake_case			:      Union[str, Any]        =			FeatureExtractionPipeline(__a							,__a							)

          snake_case			:      List[Any]        =			["""input_ids""", """token_type_ids""", """attention_mask""", """output_0""", """output_1"""]
          snake_case ,		snake_case ,		snake_case ,		snake_case			:      Tuple        =			infer_shapes(__a							,__a							)

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

          # 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 			snake_case_      (				self							)      ->				Union[str, Any]:
          snake_case			:      Tuple        =			["""input_ids""", """attention_mask""", """token_type_ids"""]
          snake_case			:      Tuple        =			{"""input_ids""": [1, 2, 3, 4], """attention_mask""": [0, 0, 0, 0], """token_type_ids""": [1, 1, 1, 1]}
          snake_case ,		snake_case			:      Dict        =			ensure_valid_input(FuncContiguousArgs()							,__a							,__a							)

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

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

          # Parameter should be reordered according to their respective place in the function:
          # (input_ids, token_type_ids, attention_mask)
          self.assertEqual(__a							,(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			:      Optional[int]        =			ensure_valid_input(FuncNonContiguousArgs()							,__a							,__a							)

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

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







     def 			snake_case_      (				self							)      ->				Union[str, Any]:
          snake_case			:      Optional[Any]        =			generate_identified_filename(Path("""/home/something/my_fake_model.onnx"""							)							,"""-test"""							)
          self.assertEqual("""/home/something/my_fake_model-test.onnx"""							,generated.as_posix()							)









'''simple docstring'''







from ..utils import DummyObject, requires_backends







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Any          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Tuple:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Tuple:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Dict:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Optional[int]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				List[Any]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[str]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				str:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Any          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Any:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[Any]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Any:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     List[str]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Dict:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				int:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     int          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Optional[int]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[str]:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Dict          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[Any]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				int:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Union[str, Any]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				List[str]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				str:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Optional[Any]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				str:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				str:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Union[str, Any]:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     List[Any]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Union[str, Any]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Any:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Dict          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Dict:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[str]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Optional[Any]:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     List[str]          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Tuple:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Tuple:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Optional[int]:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Tuple          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				List[str]:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Union[str, Any]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				Dict:
          requires_backends(cls							,["""flax"""]							)







class 					_a (metaclass=a__	):





     '''simple docstring'''



     lowerCAmelCase_  :     Tuple          =					["""flax"""]







     def __init__(				self							,*__a							,**__a							)      ->				Tuple:
          requires_backends(self							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				List[str]:
          requires_backends(cls							,["""flax"""]							)







     @classmethod
     def 			snake_case_      (				cls							,*__a							,**__a							)      ->				int:
          requires_backends(cls							,["""flax"""]							)



