

'''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     lowercase_			:




  """simple docstring"""




  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]      ,lowercase__     :  Tuple      ,lowercase__     :  Any      ,lowercase__     :  Optional[Any]    ):
   return None






class     lowercase_			:




  """simple docstring"""




  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]      ,lowercase__     :  Dict      ,lowercase__     :  List[Any]      ,lowercase__     :  int      ,lowercase__     :  Optional[Any]    ):
   return None






class     lowercase_			(unittest.TestCase   ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE					:						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       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
    self._test_export(lowercase__      ,'''tf'''      ,1_2      ,**lowercase__    )






  @require_torch
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
    self._test_export(lowercase__      ,'''pt'''      ,1_2      ,**lowercase__    )






  @require_torch
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   from transformers import BertModel

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

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






  @require_tf
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
    __lowercase													=				self._test_export(lowercase__      ,'''tf'''      ,1_2      ,**lowercase__    )
    __lowercase													=				quantize(Path(lowercase__    )    )

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






  @require_torch
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
    __lowercase													=				self._test_export(lowercase__      ,'''pt'''      ,1_2      ,**lowercase__    )
    __lowercase													=				quantize(lowercase__    )

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






  def       SCREAMING_SNAKE_CASE   (   self     :  Tuple      ,lowercase__     :  List[str]      ,lowercase__     :  List[str]      ,lowercase__     :  Optional[int]      ,lowercase__     :  List[str]=None      ,**lowercase__     :  Union[str, Any]    ):
   try:
    # Compute path
    with TemporaryDirectory() as tempdir:
     __lowercase													=				Path(lowercase__    ).joinpath('''model.onnx'''    )

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

    # Export
    convert(lowercase__      ,lowercase__      ,lowercase__      ,lowercase__      ,lowercase__      ,**lowercase__    )

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






  @require_torch
  @require_tokenizers
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   from transformers import BertModel

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






  @require_tf
  @require_tokenizers
  @slow
  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   from transformers import TFBertModel

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






  def       SCREAMING_SNAKE_CASE   (   self     :  Any      ,lowercase__     :  Dict      ,lowercase__     :  List[str]      ,lowercase__     :  Optional[int]    ):
   __lowercase													=				FeatureExtractionPipeline(lowercase__      ,lowercase__    )

   __lowercase													=				['''input_ids''', '''token_type_ids''', '''attention_mask''', '''output_0''', '''output_1''']
   __lowercase						,			__lowercase						,			__lowercase						,			__lowercase													=				infer_shapes(lowercase__      ,lowercase__    )

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

   # 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     :  List[Any]    ):
   __lowercase													=				['''input_ids''', '''attention_mask''', '''token_type_ids''']
   __lowercase													=				{'''input_ids''': [1, 2, 3, 4], '''attention_mask''': [0, 0, 0, 0], '''token_type_ids''': [1, 1, 1, 1]}
   __lowercase						,			__lowercase													=				ensure_valid_input(FuncContiguousArgs()      ,lowercase__      ,lowercase__    )

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

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

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

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

   # Should have exactly the one arg (all before the one not provided "some_other_args")
   self.assertEqual(len(lowercase__    )      ,1    )
   self.assertEqual(len(lowercase__    )      ,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     :  Union[str, Any]    ):
   __lowercase													=				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'''






def 	_A  (					):






 """simple docstring"""



 for n in range(1  ,       1000000   ):
  yield n * (n + 1) // 2


def 	_A  (					A__   ):






 """simple docstring"""



 __lowercase													=				1
 __lowercase													=				2
 while i * i <= n:
  __lowercase													=				0
  while n % i == 0:
   n //= i
   multiplicity += 1
  divisors_count *= multiplicity + 1
  i += 1
 if n > 1:
  divisors_count *= 2
 return divisors_count


def 	_A  (					):






 """simple docstring"""



 return next(i for i in triangle_number_generator() if count_divisors(A__   ) > 500   )


if __name__ == "__main__":
 print(solution())

