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





     """simple docstring"""







     def    __SCREAMING_SNAKE_CASE			(							self						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )  ->   Tuple:




           """simple docstring"""







           return None




class 				_lowerCamelCase :





     """simple docstring"""







     def    __SCREAMING_SNAKE_CASE			(							self						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )  ->   Optional[int]:




           """simple docstring"""







           return None




class 				_lowerCamelCase (      unittest.TestCase ):





     """simple docstring"""







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






     @require_tf
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Dict:




           """simple docstring"""







           for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                 self._test_export(__SCREAMING_SNAKE_CASE						,						'''tf'''						,						1_2						,						**__SCREAMING_SNAKE_CASE  )






     @require_torch
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                 self._test_export(__SCREAMING_SNAKE_CASE						,						'''pt'''						,						1_2						,						**__SCREAMING_SNAKE_CASE  )






     @require_torch
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           from transformers import BertModel

           UpperCamelCase__    :   Optional[int]					=				['''[UNK]''', '''[SEP]''', '''[CLS]''', '''[PAD]''', '''[MASK]''', '''some''', '''other''', '''words''']
           with NamedTemporaryFile(mode='''w+t'''  ) as vocab_file:
                 vocab_file.write('''\n'''.join(__SCREAMING_SNAKE_CASE  )  )
                 vocab_file.flush()
                 UpperCamelCase__    :   Union[str, Any]					=				BertTokenizerFast(vocab_file.name  )

           with TemporaryDirectory() as bert_save_dir:
                 UpperCamelCase__    :   Dict					=				BertModel(BertConfig(vocab_size=len(__SCREAMING_SNAKE_CASE  )  )  )
                 model.save_pretrained(__SCREAMING_SNAKE_CASE  )
                 self._test_export(__SCREAMING_SNAKE_CASE						,						'''pt'''						,						1_2						,						__SCREAMING_SNAKE_CASE  )






     @require_tf
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                 UpperCamelCase__    :   Optional[Any]					=				self._test_export(__SCREAMING_SNAKE_CASE						,						'''tf'''						,						1_2						,						**__SCREAMING_SNAKE_CASE  )
                 UpperCamelCase__    :   Union[str, Any]					=				quantize(Path(__SCREAMING_SNAKE_CASE  )  )

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






     @require_torch
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[Any]:




           """simple docstring"""







           for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                 UpperCamelCase__    :   int					=				self._test_export(__SCREAMING_SNAKE_CASE						,						'''pt'''						,						1_2						,						**__SCREAMING_SNAKE_CASE  )
                 UpperCamelCase__    :   str					=				quantize(__SCREAMING_SNAKE_CASE  )

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






     def    __SCREAMING_SNAKE_CASE			(							self						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE=None						,						**__SCREAMING_SNAKE_CASE  )  ->   Any:




           """simple docstring"""







           try:
                 # Compute path
                 with TemporaryDirectory() as tempdir:
                       UpperCamelCase__    :   List[str]					=				Path(__SCREAMING_SNAKE_CASE  ).joinpath('''model.onnx'''  )

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

                 # Export
                 convert(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )

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






     @require_torch
     @require_tokenizers
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Union[str, Any]:




           """simple docstring"""







           from transformers import BertModel

           UpperCamelCase__    :   Optional[int]					=				BertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random'''  )  )
           UpperCamelCase__    :   Any					=				BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random'''  )
           self._test_infer_dynamic_axis(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						'''pt'''  )






     @require_tf
     @require_tokenizers
     @slow
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Any:




           """simple docstring"""







           from transformers import TFBertModel

           UpperCamelCase__    :   Optional[Any]					=				TFBertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random'''  )  )
           UpperCamelCase__    :   Union[str, Any]					=				BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random'''  )
           self._test_infer_dynamic_axis(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						'''tf'''  )






     def    __SCREAMING_SNAKE_CASE			(							self						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )  ->   List[Any]:




           """simple docstring"""







           UpperCamelCase__    :   Dict					=				FeatureExtractionPipeline(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Optional[Any]					=				['''input_ids''', '''token_type_ids''', '''attention_mask''', '''output_0''', '''output_1''']
           UpperCamelCase__				,UpperCamelCase__				,UpperCamelCase__				,UpperCamelCase__    :   List[str]					=				infer_shapes(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )

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

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




           """simple docstring"""







           UpperCamelCase__    :   Optional[Any]					=				['''input_ids''', '''attention_mask''', '''token_type_ids''']
           UpperCamelCase__    :   int					=				{'''input_ids''': [1, 2, 3, 4], '''attention_mask''': [0, 0, 0, 0], '''token_type_ids''': [1, 1, 1, 1]}
           UpperCamelCase__				,UpperCamelCase__    :   List[Any]					=				ensure_valid_input(FuncContiguousArgs()						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )

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

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

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

           # Generated args are interleaved with another args (for instance parameter "past" in GPT2)
           UpperCamelCase__				,UpperCamelCase__    :   Optional[Any]					=				ensure_valid_input(FuncNonContiguousArgs()						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )

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

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






     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   Optional[int]:




           """simple docstring"""







           UpperCamelCase__    :   Any					=				generate_identified_filename(Path('''/home/something/my_fake_model.onnx'''  )						,						'''-test'''  )
           self.assertEqual('''/home/something/my_fake_model-test.onnx'''						,						generated.as_posix()  )




def 							SCREAMING_SNAKE_CASE_      (			UpperCamelCase__ = 5_0_0_0_0_0_0_0		):
      UpperCamelCase__    :   Any					=				set()
      UpperCamelCase__    :   Any					=				int((limit - 2_4) ** (1 / 2)		)

      UpperCamelCase__    :   Dict					=				set(range(3 ,		prime_square_limit + 1 ,		2		)		)
      primes.add(2		)
      for p in range(3 ,		prime_square_limit + 1 ,		2		):
            if p not in primes:
                  continue
            primes.difference_update(set(range(p * p ,		prime_square_limit + 1 ,		UpperCamelCase__		)		)		)

      for primea in primes:
            UpperCamelCase__    :   Dict					=				primea * primea
            for primea in primes:
                  UpperCamelCase__    :   str					=				primea * primea * primea
                  if square + cube >= limit - 1_6:
                        break
                  for primea in primes:
                        UpperCamelCase__    :   Dict					=				primea * primea * primea * primea
                        UpperCamelCase__    :   Tuple					=				square + cube + tetr
                        if total >= limit:
                              break
                        ret.add(UpperCamelCase__		)

      return len(UpperCamelCase__		)


if __name__ == "__main__":
    print(F'''{solution() = }''')


